emf 0.1.2 → 0.2.0

data/lib/emf/model/wmf/state_records.rb

@@ -0,0 +1,188 @@
+# frozen_string_literal: true
+
+module Emf
+  module Model
+    module Wmf
+      module Records
+        class StateRecord < Record
+          def initialize(type_id:, offset: nil, suffix: "")
+            super(type_id: type_id, offset: offset)
+            @suffix = suffix
+          end
+
+          attr_accessor :suffix
+        end
+
+        class SetBkColor < StateRecord
+          WIRE_FIELDS = %i[color_ref].freeze
+          WIRE_FORMAT = "V"
+          WIRE_TYPES = %i[uint32].freeze
+          PAYLOAD_BYTES = 4
+
+          def initialize(color_ref:, offset: nil, type_id: 0x0201, suffix: "")
+            super(type_id: type_id, offset: offset, suffix: suffix)
+            @color_ref = color_ref
+          end
+
+          attr_accessor :color_ref
+        end
+
+        class SetBkMode < StateRecord
+          WIRE_FIELDS = %i[mode].freeze
+          WIRE_FORMAT = "v"
+          WIRE_TYPES = %i[uint16].freeze
+          PAYLOAD_BYTES = 2
+
+          def initialize(mode:, offset: nil, type_id: 0x0102, suffix: "")
+            super(type_id: type_id, offset: offset, suffix: suffix)
+            @mode = mode
+          end
+
+          attr_accessor :mode
+        end
+
+        class SetMapMode < StateRecord
+          WIRE_FIELDS = %i[mode].freeze
+          WIRE_FORMAT = "v"
+          WIRE_TYPES = %i[uint16].freeze
+          PAYLOAD_BYTES = 2
+
+          def initialize(mode:, offset: nil, type_id: 0x0103, suffix: "")
+            super(type_id: type_id, offset: offset, suffix: suffix)
+            @mode = mode
+          end
+
+          attr_accessor :mode
+        end
+
+        class SetMapperFlags < StateRecord
+          WIRE_FIELDS = %i[flags].freeze
+          WIRE_FORMAT = "V"
+          WIRE_TYPES = %i[uint32].freeze
+          PAYLOAD_BYTES = 4
+
+          def initialize(flags:, offset: nil, type_id: 0x0231, suffix: "")
+            super(type_id: type_id, offset: offset, suffix: suffix)
+            @flags = flags
+          end
+
+          attr_accessor :flags
+        end
+
+        class SetPolyFillMode < StateRecord
+          WIRE_FIELDS = %i[mode].freeze
+          WIRE_FORMAT = "v"
+          WIRE_TYPES = %i[uint16].freeze
+          PAYLOAD_BYTES = 2
+
+          def initialize(mode:, offset: nil, type_id: 0x0106, suffix: "")
+            super(type_id: type_id, offset: offset, suffix: suffix)
+            @mode = mode
+          end
+
+          attr_accessor :mode
+        end
+
+        class SetRop2 < StateRecord
+          WIRE_FIELDS = %i[mode].freeze
+          WIRE_FORMAT = "v"
+          WIRE_TYPES = %i[uint16].freeze
+          PAYLOAD_BYTES = 2
+
+          def initialize(mode:, offset: nil, type_id: 0x0104, suffix: "")
+            super(type_id: type_id, offset: offset, suffix: suffix)
+            @mode = mode
+          end
+
+          attr_accessor :mode
+        end
+
+        class SetStretchBltMode < StateRecord
+          WIRE_FIELDS = %i[mode].freeze
+          WIRE_FORMAT = "v"
+          WIRE_TYPES = %i[uint16].freeze
+          PAYLOAD_BYTES = 2
+
+          def initialize(mode:, offset: nil, type_id: 0x0107, suffix: "")
+            super(type_id: type_id, offset: offset, suffix: suffix)
+            @mode = mode
+          end
+
+          attr_accessor :mode
+        end
+
+        class SetTextAlign < StateRecord
+          WIRE_FIELDS = %i[alignment].freeze
+          WIRE_FORMAT = "v"
+          WIRE_TYPES = %i[uint16].freeze
+          PAYLOAD_BYTES = 2
+
+          def initialize(alignment:, offset: nil, type_id: 0x012E, suffix: "")
+            super(type_id: type_id, offset: offset, suffix: suffix)
+            @alignment = alignment
+          end
+
+          attr_accessor :alignment
+        end
+
+        class SetTextCharExtra < StateRecord
+          WIRE_FIELDS = %i[char_extra].freeze
+          WIRE_FORMAT = "v"
+          WIRE_TYPES = %i[uint16].freeze
+          PAYLOAD_BYTES = 2
+
+          def initialize(char_extra:, offset: nil, type_id: 0x0108, suffix: "")
+            super(type_id: type_id, offset: offset, suffix: suffix)
+            @char_extra = char_extra
+          end
+
+          attr_accessor :char_extra
+        end
+
+        class SetTextColor < StateRecord
+          WIRE_FIELDS = %i[color_ref].freeze
+          WIRE_FORMAT = "V"
+          WIRE_TYPES = %i[uint32].freeze
+          PAYLOAD_BYTES = 4
+
+          def initialize(color_ref:, offset: nil, type_id: 0x0209, suffix: "")
+            super(type_id: type_id, offset: offset, suffix: suffix)
+            @color_ref = color_ref
+          end
+
+          attr_accessor :color_ref
+        end
+
+        class SetTextJustification < StateRecord
+          WIRE_FIELDS = %i[break_count break_extra].freeze
+          WIRE_FORMAT = "vv"
+          WIRE_TYPES = %i[uint16 uint16].freeze
+          PAYLOAD_BYTES = 4
+
+          def initialize(break_count:, break_extra:, offset: nil, type_id: 0x020A, suffix: "")
+            super(type_id: type_id, offset: offset, suffix: suffix)
+            @break_count = break_count
+            @break_extra = break_extra
+          end
+
+          attr_accessor :break_count, :break_extra
+        end
+
+        class SetLayout < StateRecord
+          WIRE_FIELDS = %i[layout reserved].freeze
+          WIRE_FORMAT = "vv"
+          WIRE_TYPES = %i[uint16 uint16].freeze
+          PAYLOAD_BYTES = 4
+
+          def initialize(layout:, reserved:, offset: nil, type_id: 0x0149, suffix: "")
+            super(type_id: type_id, offset: offset, suffix: suffix)
+            @layout = layout
+            @reserved = reserved
+          end
+
+          attr_accessor :layout, :reserved
+        end
+      end
+    end
+  end
+end

data/lib/emf/model/wmf/text_records.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module Emf
+  module Model
+    module Wmf
+      module Records
+        TextRectangle = Struct.new(:left, :top, :right, :bottom, keyword_init: true)
+
+        class TextOut < Record
+          def initialize(text:, x:, y:, padding: "\x00".b, offset: nil, type_id: 0x0521)
+            super(type_id: type_id, offset: offset)
+            @text = text
+            @x = x
+            @y = y
+            @padding = padding
+          end
+
+          attr_accessor :text, :x, :y, :padding
+        end
+
+        class ExtTextOut < TextOut
+          def initialize(text:, x:, y:, options: 0, rectangle: nil, dx: nil, padding: "\x00".b, suffix: "".b,
+                         offset: nil, type_id: 0x0A32)
+            super(text: text, x: x, y: y, padding: padding, offset: offset, type_id: type_id)
+            @options = options
+            @rectangle = rectangle
+            @dx = dx
+            @suffix = suffix
+          end
+
+          attr_accessor :options, :rectangle, :dx, :suffix
+        end
+      end
+    end
+  end
+end

data/lib/emf/model/wmf.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Emf
+  module Model
+    module Wmf
+      autoload :Header, "emf/model/wmf/header"
+      autoload :PlaceableHeader, "emf/model/wmf/header"
+      autoload :Records, "emf/model/wmf/records"
+    end
+  end
+end

data/lib/emf/model.rb

@@ -2,10 +2,12 @@
 
 module Emf
   module Model
+    autoload :Diagnostic, "emf/model/diagnostic"
     autoload :Metafile, "emf/model/metafile"
     autoload :Record, "emf/model/record"
     autoload :Visitor, "emf/model/visitor"
     autoload :Geometry, "emf/model/geometry"
     autoload :Emr, "emf/model/emr"
+    autoload :Wmf, "emf/model/wmf"
   end
 end

data/lib/emf/native/bitmap_fields.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+module Emf
+  module Native
+    module BitmapFields
+      # family => [EMR type, fixed size including EMR header]
+      LAYOUTS = {
+        94 => [76, 100], 95 => [77, 108], 96 => [78, 128],
+        97 => [79, 140], 98 => [80, 76], 99 => [81, 80],
+        100 => [93, 32], 101 => [94, 32],
+        102 => [114, 108], 103 => [116, 108]
+      }.freeze
+      POINTERS = %i[off_bmi_src cb_bmi_src off_bits_src cb_bits_src].freeze
+      BLT = %i[x_dest y_dest cx_dest cy_dest dw_rop x_src y_src].freeze
+      DIB = %i[x_dest y_dest x_src y_src cx_src cy_src off_bmi_src cb_bmi_src off_bits_src cb_bits_src i_usage_src dw_rop cx_dest
+               cy_dest].freeze
+      BRUSH = %i[ih_brush i_usage off_bmi cb_bmi off_bits cb_bits].freeze
+
+      def self.call(payload, family, raw)
+        return GradientFields.call(payload, raw) if family == 93
+
+        type, fixed = LAYOUTS.fetch(family)
+        validate(payload, raw, fixed)
+        suffix = raw.byteslice((payload.bytesize + 8)..)
+        fields = if [93, 94].include?(type)
+                   BRUSH.zip(payload.unpack("V6")).to_h.merge(body: payload.byteslice(24..) + suffix)
+                 else
+                   bounds = { rcl_bounds: %i[left top right bottom].zip(payload.unpack("l<4")).to_h }
+                   bounds.merge(transfer(payload, type, fixed, suffix))
+                 end
+        [Emr::Binary::Records.lookup(type), fields]
+      end
+
+      def self.transfer(payload, type, fixed, suffix)
+        case type
+        when 76, 77
+          fields = BLT.zip(payload.byteslice(16, 28).unpack("l<4Vl<2")).to_h
+          fields[:xform_usage_etc] = payload.byteslice(44, 32).sub(/\x00+\z/n, "")
+          fields.merge!(POINTERS.zip(payload.byteslice(76, 16).unpack("V4")).to_h)
+          fields.merge!(%i[cx_src cy_src].zip(payload.byteslice(92, 8).unpack("l<2")).to_h) if type == 77
+          fields.merge(body: payload.byteslice((fixed - 8)..) + suffix)
+        when 81
+          DIB.zip(payload.byteslice(16, 56).unpack("l<6V6l<2")).to_h.merge(trailing: payload.byteslice(72..) + suffix)
+        else
+          { body: payload.byteslice(16..) + suffix }
+        end
+      end
+
+      # The snapshot payload always starts with the fixed prefix; descriptors are
+      # not checked against the record, because Ruby keeps the rest as opaque body.
+      def self.validate(payload, raw, fixed)
+        return unless payload.bytesize < fixed - 8 || raw.bytesize < payload.bytesize + 8
+
+        raise FormatError, "invalid native bitmap payload length"
+      end
+    end
+  end
+end

data/lib/emf/native/diagnostic_contract.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module Emf
+  module Native
+    # Snapshot recovery kinds are provenance, independently of public error text.
+    class DiagnosticContract
+      def initialize(snapshot, input)
+        @snapshot = snapshot
+        @input = input
+      end
+
+      def call(metafile)
+        return metafile if @snapshot.diagnostics.empty?
+
+        offsets = @snapshot.table.each_slice(5).map { |entry| entry[1] }
+        diagnostics = @snapshot.diagnostics.flat_map do |kind, has_type, type, _reserved, offset|
+          index = offsets.bsearch_index { |candidate| candidate >= offset } || offsets.length
+          code = has_type == 1 ? type : @input.unpack1("V", offset: offset) || 0
+          if kind == Diagnostics::INVALID_PAYLOAD
+            recovered_diagnostics(offset, index + 1, code)
+          else
+            [Model::Diagnostic.new(record_index: index + 1, record_code: code, byte_offset: offset, disposition: :skipped)]
+          end
+        end
+        metafile.with_diagnostics(diagnostics.sort_by(&:byte_offset))
+      end
+
+      private
+
+      def recovered_diagnostics(offset, index, code)
+        return [] if Hydrator::OPAQUE_BODY_TYPES.include?(code)
+
+        diagnostics = []
+        Emr::Parser.read_record_at(@input, offset, [], diagnostics: diagnostics, record_index: index)
+        diagnostics
+      end
+    end
+  end
+end

data/lib/emf/native/diagnostics.rb

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+require "stringio"
+
+module Emf
+  module Native
+    # Turns native snapshot diagnostics into the Ruby parser's ParseErrors.
+    #
+    # Framing diagnostics (kinds 1-3) carry their numbers, so the Ruby message
+    # is rebuilt from them. A kind-4 diagnostic only says that native could not
+    # decode a record's payload, not why, and native decodes some bodies Ruby
+    # keeps opaque. The Ruby parser is the contract for such a record, so its own
+    # per-record reader decides: it accepts the record as typed, or preserves it as
+    # Raw with its own message. Record bodies native hydrates as opaque classes are
+    # never rejected by Ruby, so their diagnostic is dropped without a Ruby read.
+    class Diagnostics
+      INVALID_PAYLOAD = 4
+      Recovery = Struct.new(:adapter, :errors, :wire)
+
+      def initialize(snapshot, input)
+        @snapshot = snapshot
+        @input = input
+        @recovered = invalid_payload_offsets.to_h { |offset, type| [offset, recover(offset, type)] }
+      end
+
+      def recovering?
+        !@recovered.empty?
+      end
+
+      def recovered?(offset)
+        @recovered.key?(offset)
+      end
+
+      def adapter_at(offset)
+        @recovered[offset]&.adapter
+      end
+
+      def emf_plus_at(offset)
+        wire = @recovered.fetch(offset).wire
+        Emr::Parser.extract_emf_plus(wire) if wire.is_a?(Emr::Binary::Records::Comment)
+      end
+
+      def errors
+        @snapshot.diagnostics.flat_map do |kind, has_type, type, reserved, offset, detail1, detail2|
+          raise FormatError, "invalid native snapshot diagnostic" unless (1..4).cover?(kind) && (0..1).cover?(has_type) && reserved.zero?
+          next @recovered.fetch(offset).errors if kind == INVALID_PAYLOAD
+
+          [ParseError.new(offset: offset, record_code: has_type == 1 ? type : nil, message: message(kind, offset, detail1, detail2))]
+        end
+      end
+
+      private
+
+      def invalid_payload_offsets
+        @snapshot.diagnostics.filter_map do |kind, has_type, type, _reserved, offset|
+          [offset, has_type == 1 ? type : nil] if kind == INVALID_PAYLOAD
+        end
+      end
+
+      def recover(offset, type)
+        return Recovery.new(nil, [], nil) if Hydrator::OPAQUE_BODY_TYPES.include?(type)
+
+        errors = []
+        io = StringIO.new(@input)
+        io.pos = offset
+        wire, suffix = Emr::Parser.read_record(io, offset, errors)
+        adapter = Model::Emr::Records::WireAdapter.new(wire: wire, offset: offset, suffix: suffix) if wire
+        Recovery.new(adapter, errors, wire)
+      end
+
+      def message(kind, offset, detail1, detail2)
+        case kind
+        when 1 then "truncated record header at offset #{offset} (#{detail1} bytes)"
+        when 2 then "record nSize #{detail1} < 8 bytes (offset #{offset})"
+        when 3 then "truncated record at offset #{offset} (claimed #{detail1}, got #{detail2 - 8})"
+        else "native parse diagnostic #{kind} at offset #{offset} (#{detail1}, #{detail2})"
+        end
+      end
+    end
+  end
+end

data/lib/emf/native/emf_plus_loader.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+require_relative "loader"
+
+module Emf
+  module Native
+    # Adds the independent EMF+ snapshot call (emf_document_emf_plus_snapshot_v1)
+    # to the production Loader without touching its outer-snapshot signatures.
+    class EmfPlusLoader < Loader
+      # Version 2 frames each comment on its own, recovering from malformed framing
+      # like the Ruby framer, and types SetTSClip (family 0x106).
+      SNAPSHOT_VERSION = 2
+      # struct_size, version, max_output_bytes
+      DEFAULT_OPTIONS = [16, SNAPSHOT_VERSION, 1 << 30].pack("VVQ<").freeze
+
+      def initialize(path)
+        super
+        signature = [POINTER, POINTER, POINTER, POINTER, POINTER]
+        @functions[:emf_document_emf_plus_snapshot_v1] = Fiddle::Function.new(
+          @library["emf_document_emf_plus_snapshot_v1"], signature, Fiddle::TYPE_INT
+        )
+      rescue Fiddle::DLError => e
+        raise Unavailable, "native EMF+ snapshot could not load: #{e.message}"
+      end
+
+      # The EPSN buffer for the EMF file `bytes`; raises FormatError for malformed
+      # nested EMF+ and Error for a resource limit.
+      def emf_plus_snapshot(bytes)
+        document(bytes.b) do |handle|
+          buffer(:emf_document_emf_plus_snapshot_v1, handle, DEFAULT_OPTIONS, 0)
+        end
+      end
+    end
+  end
+end

data/lib/emf/native/emf_plus_snapshot.rb

@@ -0,0 +1,96 @@
+# frozen_string_literal: true
+
+module Emf
+  module Native
+    # Reader for the native EMF+ snapshot (EPSN versions 1 and 2, emf-plus-snapshot-v1.md).
+    # It validates every length against the buffer, so a truncated or inconsistent
+    # snapshot raises FormatError rather than yielding partial data.
+    class EmfPlusSnapshot
+      HEADER_BYTES = 40
+      SEGMENT_BYTES = 32
+      FRAME_HEADER_BYTES = 64
+      DIAGNOSTIC_BYTES = 24
+
+      Segment = Struct.new(:record_index, :logical_start, :payload_length, :data_start, keyword_init: true)
+      Frame = Struct.new(:index, :offset, :first_segment, :last_segment, :type, :flags, :frame_size, :data_size,
+                         :family, :raw, :typed, keyword_init: true)
+      # kind: :empty_slot, :wrong_type or :object_id_out_of_range (the names of
+      # Emf::EmfPlus::ObjectTable diagnostics); role: the required object type.
+      Diagnostic = Struct.new(:kind, :object_type, :frame_index, :id, :actual_type, keyword_init: true)
+
+      KINDS = { 1 => :empty_slot, 2 => :wrong_type, 3 => :object_id_out_of_range }.freeze
+      # The family tags of the frame table.
+      FAMILIES = { 0 => :opaque, 1 => :header, 2 => :empty, 3 => :clear, 4 => :rendering_origin, 5 => :stack_index,
+                   6 => :begin_container, 7 => :matrix, 8 => :pair, 9 => :scalar, 10 => :clip_rect,
+                   0x101 => :drawing, 0x102 => :text, 0x103 => :effect, 0x104 => :ts_graphics,
+                   0x105 => :object, 0x106 => :ts_clip }.freeze
+      VERSIONS = [1, 2].freeze
+
+      attr_reader :segments, :frames, :diagnostics
+
+      def initialize(buffer)
+        @buffer = buffer.b
+        read_header
+        @segments = read_segments
+        @frames = read_frames
+        @diagnostics = read_diagnostics
+        raise FormatError, "EMF+ snapshot has trailing bytes" unless @cursor == @buffer.bytesize
+      end
+
+      private
+
+      def read_header
+        raise FormatError, "EMF+ snapshot is truncated" if @buffer.bytesize < HEADER_BYTES
+
+        magic, version, total, @segment_count, @frame_count, @diagnostic_count = @buffer.unpack("a4VQ<4")
+        raise FormatError, "not an EMF+ snapshot" unless magic == "EPSN"
+        raise FormatError, "unsupported EMF+ snapshot version #{version}" unless VERSIONS.include?(version)
+        raise FormatError, "EMF+ snapshot length mismatch" unless total == @buffer.bytesize
+
+        @cursor = HEADER_BYTES
+      end
+
+      def take(length)
+        raise FormatError, "EMF+ snapshot is truncated" if length.negative? || length > @buffer.bytesize - @cursor
+
+        @buffer.byteslice(@cursor, length).tap { @cursor += length }
+      end
+
+      def read_segments
+        Array.new(checked_count(@segment_count, SEGMENT_BYTES)) do
+          index, start, length, data_start = take(SEGMENT_BYTES).unpack("Q<4")
+          Segment.new(record_index: index, logical_start: start, payload_length: length, data_start: data_start)
+        end
+      end
+
+      def read_frames
+        Array.new(checked_count(@frame_count, FRAME_HEADER_BYTES)) do
+          head = take(FRAME_HEADER_BYTES)
+          index, offset, first, last, type, flags, size, data_size, tag, typed_length, raw_length = head.unpack("Q<4vvVVVQ<2")
+          raw = take(raw_length)
+          raise FormatError, "EMF+ snapshot frame size mismatch" unless raw_length == size
+
+          Frame.new(index: index, offset: offset, first_segment: first, last_segment: last, type: type, flags: flags,
+                    frame_size: size, data_size: data_size, family: FAMILIES.fetch(tag) { raise FormatError, "unknown EMF+ family #{tag}" },
+                    raw: raw, typed: take(typed_length))
+        end
+      end
+
+      def read_diagnostics
+        Array.new(checked_count(@diagnostic_count, DIAGNOSTIC_BYTES)) do
+          kind, role, frame, id, actual = take(DIAGNOSTIC_BYTES).unpack("VVQ<VV")
+          Diagnostic.new(kind: KINDS.fetch(kind) { raise FormatError, "unknown EMF+ diagnostic kind #{kind}" },
+                         object_type: role, frame_index: frame, id: id, actual_type: actual)
+        end
+      end
+
+      # A count the remaining bytes cannot possibly hold is corrupt; this also
+      # bounds Array.new before any allocation.
+      def checked_count(count, minimum)
+        raise FormatError, "EMF+ snapshot count exceeds its length" if count > (@buffer.bytesize - @cursor) / minimum
+
+        count
+      end
+    end
+  end
+end

data/lib/emf/native/emf_plus_source.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Emf
+  module Native
+    # Builds the Metafile#emf_plus_stream source for a native-backed metafile.
+    # The library is resolved at parse time; Native::EmfPlusStream loads lazily.
+    # A reload rebuilds from the current comment bytes, not the original input.
+    module EmfPlusSource
+      module_function
+
+      def call(input)
+        library = LibraryPath.new.call
+        lambda do |metafile, reload|
+          require_relative "emf_plus_stream"
+          EmfPlusStream.from_metafile(metafile, bytes: reload ? nil : input, library: library)
+        end
+      end
+    end
+  end
+end