emf 0.1.0

data/lib/emf/emr/parser.rb

@@ -0,0 +1,185 @@
+# frozen_string_literal: true
+
+require "stringio"
+
+module Emf
+  module Emr
+    module Parser
+      module_function
+
+      def call(bytes)
+        raise FormatError, "input too large (#{bytes.bytesize} > #{MAX_INPUT_BYTES}); refusing to parse" if bytes.bytesize > MAX_INPUT_BYTES
+        raise FormatError, "not an EMF file (signature mismatch)" unless Emf::Detector.call(bytes) == :emf
+
+        io = StringIO.new(bytes, "rb")
+        header_wire = read_header(io)
+        header = Model::Emr::Header.from_wire(header_wire)
+
+        records = []
+        errors = []
+        emf_plus_bytes = +""
+        trailing = +""
+
+        until io.eof?
+          offset = io.pos
+          wire = read_record(io, offset, errors)
+          break if wire.nil?
+
+          records << Model::Emr::Records::WireAdapter.new(wire: wire, offset: offset)
+          emf_plus_bytes << extract_emf_plus(wire) if wire.is_a?(Emf::Emr::Binary::Records::Comment)
+
+          if wire.is_a?(Emf::Emr::Binary::Records::Eof)
+            trailing << io.read until io.eof?
+            break
+          end
+        end
+
+        Model::Metafile.new(
+          format: emf_plus_bytes.empty? ? :emf : :emf_plus,
+          header: header,
+          records: records,
+          errors: errors,
+          emf_plus: emf_plus_bytes.empty? ? nil : emf_plus_bytes,
+          trailing: trailing
+        )
+      end
+
+      def read_header(io)
+        # Peek at the first 8 bytes to determine the record's nSize.
+        head = io.read(8)
+        raise FormatError, "truncated EMF header" if head.nil? || head.bytesize < 8
+
+        _type, n_size = head.unpack("VV")
+        raise FormatError, "EMF header nSize too small: #{n_size}" if n_size < 8
+
+        io.seek(0)
+        full = io.read(n_size)
+        if full.nil? || full.bytesize < n_size
+          raise FormatError,
+                "truncated EMF header (claimed #{n_size}, got #{full&.bytesize || 0})"
+        end
+
+        Emf::Emr::Binary::Header.read(full)
+      end
+
+      # Per-type byte-size validation for records with variable-length arrays.
+      # If the declared count exceeds what nSize can hold, the bytes are
+      # corrupt and we should preserve them as Raw rather than letting bindata
+      # allocate a giant array. The element size is bytes per array entry.
+      VARIABLE_ARRAY_RECORDS = {
+        Binary::TypeCodes::POLYGON => { count_offset: 24, element_size: 8 },
+        Binary::TypeCodes::POLYLINE => { count_offset: 24, element_size: 8 },
+        Binary::TypeCodes::POLYBEZIER => { count_offset: 24, element_size: 8 },
+        Binary::TypeCodes::POLYBEZIERTO => { count_offset: 24, element_size: 8 },
+        Binary::TypeCodes::POLYLINETO => { count_offset: 24, element_size: 8 },
+        Binary::TypeCodes::POLYGON16 => { count_offset: 24, element_size: 4 },
+        Binary::TypeCodes::POLYLINE16 => { count_offset: 24, element_size: 4 },
+        Binary::TypeCodes::POLYBEZIER16 => { count_offset: 24, element_size: 4 },
+        Binary::TypeCodes::POLYBEZIERTO16 => { count_offset: 24, element_size: 4 },
+        Binary::TypeCodes::POLYLINETO16 => { count_offset: 24, element_size: 4 },
+        Binary::TypeCodes::POLYDRAW => { count_offset: 24, element_size: 9 },
+        Binary::TypeCodes::POLYDRAW16 => { count_offset: 24, element_size: 5 },
+        # Multi-polygon records have TWO variable arrays: aPolyCounts
+        # (nPolys uint32s, 4 bytes each) and aptl/apts (cTotal entries).
+        # The count1 entries are ALWAYS uint32 (4 bytes); element_size
+        # applies only to the count2 (point) array.
+        Binary::TypeCodes::POLYPOLYGON => { count_offset: 24, count2_offset: 28, element_size: 8 },
+        Binary::TypeCodes::POLYPOLYLINE => { count_offset: 24, count2_offset: 28, element_size: 8 },
+        Binary::TypeCodes::POLYPOLYGON16 => { count_offset: 24, count2_offset: 28, element_size: 4 },
+        Binary::TypeCodes::POLYPOLYLINE16 => { count_offset: 24, count2_offset: 28, element_size: 4 }
+      }.freeze
+
+      MAX_SANE_ARRAY_LENGTH = 1_000_000
+      # Bounds the whole-file parse: a 100 MB EMF is unusual; refuse bigger.
+      MAX_INPUT_BYTES = 200 * 1024 * 1024
+
+      def variable_array_sane?(type_id, n_size, head, payload)
+        spec = VARIABLE_ARRAY_RECORDS[type_id]
+        return true unless spec
+
+        full = head + payload
+        return true if full.bytesize < spec[:count_offset] + 4
+
+        count = read_uint32(full, spec[:count_offset])
+        return false if count > MAX_SANE_ARRAY_LENGTH
+
+        # For single-array records, element_size is the per-entry size.
+        # For multi-array records, the first array (aPolyCounts) entries
+        # are always uint32 (4 bytes); element_size applies only to the
+        # second array (aptl/apts).
+        first_array_entry_size = spec[:count2_offset] ? 4 : spec[:element_size]
+        bytes_needed = spec[:count_offset] + 4 + (count * first_array_entry_size)
+        return false if bytes_needed > n_size
+
+        # Multi-array records also need to validate the second count.
+        return true unless spec[:count2_offset]
+
+        count2 = read_uint32(full, spec[:count2_offset])
+        return false if count2 > MAX_SANE_ARRAY_LENGTH
+
+        bytes_needed + (count2 * spec[:element_size]) <= n_size
+      end
+
+      def read_uint32(bytes, offset)
+        bytes.getbyte(offset) |
+          (bytes.getbyte(offset + 1) << 8) |
+          (bytes.getbyte(offset + 2) << 16) |
+          (bytes.getbyte(offset + 3) << 24)
+      end
+
+      def read_record(io, offset, errors)
+        head = io.read(8)
+        return nil if head.nil? || head.empty?
+
+        type_id, n_size = head.unpack("VV")
+        if n_size < 8
+          errors << ParseError.new(offset: offset, record_code: type_id,
+                                   message: "record nSize #{n_size} < 8 bytes (offset #{offset})")
+          return nil
+        end
+
+        payload = io.read(n_size - 8)
+        if payload.nil? || payload.bytesize < n_size - 8
+          errors << ParseError.new(offset: offset, record_code: type_id,
+                                   message: "truncated record at offset #{offset} (claimed #{n_size}, got #{payload&.bytesize || 0})")
+          return nil
+        end
+
+        unless variable_array_sane?(type_id, n_size, head, payload)
+          errors << ParseError.new(
+            offset: offset, record_code: type_id,
+            message: "variable-array record at offset #{offset} declares " \
+                     "more entries than nSize allows; preserving as Raw"
+          )
+          return build_raw(head, payload)
+        end
+
+        wire_class = Emf::Emr::Binary::Records.lookup(type_id)
+        wire_class.read(head + payload)
+      rescue StandardError => e
+        errors << ParseError.new(offset: offset, record_code: type_id,
+                                 message: "#{e.class}: #{e.message}")
+        build_raw(head, payload)
+      end
+
+      def build_raw(head, payload)
+        Emf::Emr::Binary::Records::Raw.read(head + (payload || +""))
+      end
+
+      EMF_PLUS_IDENTIFIER = 0x2B464D45 # "EMF+" little-endian
+
+      def extract_emf_plus(comment_wire)
+        return +"" unless comment_wire.cb_data&.>= 4
+
+        identifier = comment_wire.data.getbyte(0) |
+                     (comment_wire.data.getbyte(1) << 8) |
+                     (comment_wire.data.getbyte(2) << 16) |
+                     (comment_wire.data.getbyte(3) << 24)
+        return +"" unless identifier == EMF_PLUS_IDENTIFIER
+
+        # Payload after the 4-byte identifier is the EMF+ record(s).
+        comment_wire.data.bytes[4..].pack("C*")
+      end
+    end
+  end
+end

data/lib/emf/emr/path_association.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+# Placeholder for TODO.impl/11-emf-parser.md's path-association pass.
+module Emf
+  module Emr
+    class PathAssociation
+      def initialize
+        @table = {}
+      end
+
+      def lookup(render_offset)
+        @table.fetch(render_offset, nil)
+      end
+    end
+  end
+end

data/lib/emf/emr/serializer.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Emf
+  module Emr
+    module Serializer
+      module_function
+
+      def call(metafile)
+        bytes = +""
+        bytes << metafile.header.to_wire.to_binary_s
+        metafile.records.each do |record|
+          case record
+          when Model::Emr::Records::WireAdapter
+            bytes << record.wire.to_binary_s
+          else
+            raise SerializeError, "cannot serialize #{record.class} (TODO 10 lands domain to_wire)"
+          end
+        end
+        bytes << metafile.trailing
+        bytes
+      end
+    end
+  end
+end

data/lib/emf/emr.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+module Emf
+  module Emr
+    autoload :Parser, "emf/emr/parser"
+    autoload :Serializer, "emf/emr/serializer"
+    autoload :PathAssociation, "emf/emr/path_association"
+    autoload :Binary, "emf/emr/binary"
+  end
+end

data/lib/emf/error.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Emf
+  class Error < StandardError; end
+
+  class FormatError < Error; end
+
+  class ParseError < Error
+    attr_reader :offset, :record_code
+
+    def initialize(offset:, record_code:, message:)
+      @offset = offset
+      @record_code = record_code
+      super(message)
+    end
+  end
+
+  class SerializeError < Error; end
+end

data/lib/emf/model/emr/header.rb

@@ -0,0 +1,93 @@
+# frozen_string_literal: true
+
+module Emf
+  module Model
+    module Emr
+      # EMF metafile header. Preserves all wire fields verbatim so the
+      # serializer can round-trip byte-faithfully.
+      class Header
+        def initialize(bounds:, frame:, signature:, version:, n_bytes:, n_records:,
+                       n_handles:, s_reserved:, n_description:, off_description:,
+                       n_pal_entries:, device_pixels:, device_mm:, cb_pixel_format:,
+                       off_pixel_format:, b_open_gl:, szl_micrometers:,
+                       n_size: 100, trailing: +"", description: nil)
+          @bounds = bounds
+          @frame = frame
+          @signature = signature
+          @version = version
+          @n_bytes = n_bytes
+          @n_records = n_records
+          @n_handles = n_handles
+          @s_reserved = s_reserved
+          @n_description = n_description
+          @off_description = off_description
+          @n_pal_entries = n_pal_entries
+          @device_pixels = device_pixels
+          @device_mm = device_mm
+          @cb_pixel_format = cb_pixel_format
+          @off_pixel_format = off_pixel_format
+          @b_open_gl = b_open_gl
+          @szl_micrometers = szl_micrometers
+          @n_size = n_size
+          @trailing = trailing
+          @description = description
+        end
+
+        attr_reader :bounds, :frame, :signature, :version, :n_bytes, :n_records,
+                    :n_handles, :s_reserved, :n_description, :off_description,
+                    :n_pal_entries, :device_pixels, :device_mm, :cb_pixel_format,
+                    :off_pixel_format, :b_open_gl, :szl_micrometers, :n_size,
+                    :trailing, :description
+
+        def self.from_wire(wire)
+          new(
+            bounds: Geometry::Rect.from_wire(wire.rcl_bounds),
+            frame: Geometry::Rect.from_wire(wire.rcl_frame),
+            signature: wire.d_signature,
+            version: wire.n_version,
+            n_bytes: wire.n_bytes,
+            n_records: wire.n_records,
+            n_handles: wire.n_handles,
+            s_reserved: wire.s_reserved,
+            n_description: wire.n_description,
+            off_description: wire.off_description,
+            n_pal_entries: wire.n_pal_entries,
+            device_pixels: Geometry::Size.from_wire(wire.szl_device),
+            device_mm: Geometry::Size.from_wire(wire.szl_millimeters),
+            cb_pixel_format: wire.cb_pixel_format,
+            off_pixel_format: wire.off_pixel_format,
+            b_open_gl: wire.b_open_gl,
+            szl_micrometers: Geometry::Size.from_wire(wire.szl_micrometers),
+            n_size: wire.n_size,
+            trailing: wire.trailing.to_s
+          )
+        end
+
+        def to_wire
+          Emf::Emr::Binary::Header.new(
+            i_type: 1,
+            n_size: n_size,
+            rcl_bounds: bounds.to_wire,
+            rcl_frame: frame.to_wire,
+            d_signature: signature,
+            n_version: version,
+            n_bytes: n_bytes,
+            n_records: n_records,
+            n_handles: n_handles,
+            s_reserved: s_reserved,
+            n_description: n_description,
+            off_description: off_description,
+            n_pal_entries: n_pal_entries,
+            szl_device: device_pixels.to_wire,
+            szl_millimeters: device_mm.to_wire,
+            cb_pixel_format: cb_pixel_format,
+            off_pixel_format: off_pixel_format,
+            b_open_gl: b_open_gl,
+            szl_micrometers: szl_micrometers.to_wire,
+            trailing: trailing
+          )
+        end
+      end
+    end
+  end
+end

data/lib/emf/model/emr/records.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+module Emf
+  module Model
+    module Emr
+      module Records
+        # Adapter that wraps a bindata wire record so the Metafile container
+        # can hold domain-shape objects even for record types whose dedicated
+        # domain class hasn't been written yet (TODO 10). When a real domain
+        # class exists, the parser uses it instead.
+        #
+        # `wire` is the parsed Emf::Emr::Binary::Records::* instance.
+        # `offset` is the byte offset within the source stream (for diagnostics).
+        class WireAdapter < Emf::Model::Record
+          Emf::Model::Visitor.register_visit(:visit_emr_wire_record, self)
+
+          def initialize(wire:, offset: nil)
+            @wire = wire
+            @offset = offset
+          end
+
+          attr_reader :wire, :offset
+
+          def type_id
+            @wire.i_type
+          end
+
+          def accept(visitor)
+            visitor.visit_emr_wire_record(self)
+          end
+
+          def ==(other)
+            other.is_a?(self.class) && wire.to_binary_s == other.wire.to_binary_s
+          end
+          alias eql? ==
+
+          def hash
+            [self.class, wire.to_binary_s].hash
+          end
+
+          def inspect
+            "#<#{self.class.name} type_id=#{type_id} (#{(@wire.class.name || '').split('::').last})>"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/emf/model/emr.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+module Emf
+  module Model
+    module Emr
+      autoload :Header, "emf/model/emr/header"
+      autoload :Records, "emf/model/emr/records"
+    end
+  end
+end

data/lib/emf/model/geometry/color.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+module Emf
+  module Model
+    module Geometry
+      class Color
+        def initialize(red:, green:, blue:, alpha: 255)
+          @red = coerce(red)
+          @green = coerce(green)
+          @blue = coerce(blue)
+          @alpha = coerce(alpha)
+        end
+
+        attr_reader :red, :green, :blue, :alpha
+
+        def self.from_wire(wire)
+          new(red: wire.red, green: wire.green, blue: wire.blue, alpha: wire.reserved.zero? ? 255 : wire.reserved)
+        end
+
+        def to_wire
+          Binary::Types::ColorRef.new(red: red, green: green, blue: blue, reserved: alpha)
+        end
+
+        def to_hex
+          alpha == 255 ? format("#%02X%02X%02X", red, green, blue) : to_hex_rgba
+        end
+
+        def to_hex_rgba
+          format("#%02X%02X%02X%02X", red, green, blue, alpha)
+        end
+
+        def self.black
+          new(red: 0, green: 0, blue: 0)
+        end
+
+        def self.white
+          new(red: 255, green: 255, blue: 255)
+        end
+
+        def self.transparent
+          new(red: 0, green: 0, blue: 0, alpha: 0)
+        end
+
+        def ==(other)
+          other.is_a?(self.class) &&
+            red == other.red && green == other.green &&
+            blue == other.blue && alpha == other.alpha
+        end
+        alias eql? ==
+
+        def hash
+          [self.class, red, green, blue, alpha].hash
+        end
+
+        def inspect
+          "#<#{self.class.name} #{to_hex_rgba}>"
+        end
+
+        private
+
+        def coerce(value)
+          Integer(value)
+        end
+      end
+    end
+  end
+end

data/lib/emf/model/geometry/matrix.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+module Emf
+  module Model
+    module Geometry
+      class Matrix
+        IDENTITY = {
+          m11: 1.0, m12: 0.0, m21: 0.0, m22: 1.0, dx: 0.0, dy: 0.0
+        }.freeze
+
+        def initialize(m11:, m12:, m21:, m22:, dx:, dy:)
+          @m11 = m11.to_f
+          @m12 = m12.to_f
+          @m21 = m21.to_f
+          @m22 = m22.to_f
+          @dx = dx.to_f
+          @dy = dy.to_f
+        end
+
+        attr_reader :m11, :m12, :m21, :m22, :dx, :dy
+
+        def self.from_wire(wire)
+          new(m11: wire.m11, m12: wire.m12, m21: wire.m21, m22: wire.m22, dx: wire.dx, dy: wire.dy)
+        end
+
+        def to_wire
+          Binary::Types::XForm.new(m11: m11, m12: m12, m21: m21, m22: m22, dx: dx, dy: dy)
+        end
+
+        def self.identity
+          new(**IDENTITY)
+        end
+
+        def identity?
+          m11 == 1.0 && m12 == 0.0 && m21 == 0.0 && m22 == 1.0 && dx == 0.0 && dy == 0.0
+        end
+
+        def ==(other)
+          other.is_a?(self.class) &&
+            m11 == other.m11 && m12 == other.m12 &&
+            m21 == other.m21 && m22 == other.m22 &&
+            dx == other.dx && dy == other.dy
+        end
+        alias eql? ==
+
+        def hash
+          [self.class, m11, m12, m21, m22, dx, dy].hash
+        end
+      end
+    end
+  end
+end

data/lib/emf/model/geometry/point.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module Emf
+  module Model
+    module Geometry
+      class Point
+        def initialize(x:, y:)
+          @x = x
+          @y = y
+        end
+
+        attr_reader :x, :y
+
+        def self.from_wire(wire)
+          new(x: wire.x, y: wire.y)
+        end
+
+        def to_wire
+          Binary::Types::PointL.new(x: x, y: y)
+        end
+
+        def translate(dx, dy)
+          self.class.new(x: x + dx, y: y + dy)
+        end
+
+        def ==(other)
+          other.is_a?(self.class) && x == other.x && y == other.y
+        end
+        alias eql? ==
+
+        def hash
+          [self.class, x, y].hash
+        end
+
+        def inspect
+          "#<#{self.class.name} x=#{x} y=#{y}>"
+        end
+      end
+    end
+  end
+end

data/lib/emf/model/geometry/point_f.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module Emf
+  module Model
+    module Geometry
+      class PointF
+        def initialize(x:, y:)
+          @x = x.to_f
+          @y = y.to_f
+        end
+
+        attr_reader :x, :y
+
+        def self.from_wire(wire)
+          new(x: wire.x, y: wire.y)
+        end
+
+        def to_wire
+          Binary::Types::PointD.new(x: x, y: y)
+        end
+
+        def ==(other)
+          other.is_a?(self.class) && x == other.x && y == other.y
+        end
+        alias eql? ==
+
+        def hash
+          [self.class, x, y].hash
+        end
+      end
+    end
+  end
+end

data/lib/emf/model/geometry/point_s.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module Emf
+  module Model
+    module Geometry
+      class PointS
+        def initialize(x:, y:)
+          @x = x
+          @y = y
+        end
+
+        attr_reader :x, :y
+
+        def self.from_wire(wire)
+          new(x: wire.x, y: wire.y)
+        end
+
+        def to_wire
+          Binary::Types::PointS.new(x: x, y: y)
+        end
+
+        def ==(other)
+          other.is_a?(self.class) && x == other.x && y == other.y
+        end
+        alias eql? ==
+
+        def hash
+          [self.class, x, y].hash
+        end
+      end
+    end
+  end
+end

data/lib/emf/model/geometry/rect.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+module Emf
+  module Model
+    module Geometry
+      class Rect
+        def initialize(left:, top:, right:, bottom:)
+          @left = left
+          @top = top
+          @right = right
+          @bottom = bottom
+        end
+
+        attr_reader :left, :top, :right, :bottom
+
+        def self.from_wire(wire)
+          new(left: wire.left, top: wire.top, right: wire.right, bottom: wire.bottom)
+        end
+
+        def to_wire
+          Binary::Types::RectL.new(left: left, top: top, right: right, bottom: bottom)
+        end
+
+        def width
+          right - left
+        end
+
+        def height
+          bottom - top
+        end
+
+        def empty?
+          width <= 0 || height <= 0
+        end
+
+        def contains?(point)
+          point.x.between?(left, right) && point.y.between?(top, bottom)
+        end
+
+        def ==(other)
+          other.is_a?(self.class) &&
+            left == other.left && top == other.top &&
+            right == other.right && bottom == other.bottom
+        end
+        alias eql? ==
+
+        def hash
+          [self.class, left, top, right, bottom].hash
+        end
+
+        def inspect
+          "#<#{self.class.name} left=#{left} top=#{top} right=#{right} bottom=#{bottom}>"
+        end
+      end
+    end
+  end
+end