emf 0.1.2 → 0.2.0

data/lib/emf/conformance/rules/emf_state.rb

@@ -0,0 +1,244 @@
+# frozen_string_literal: true
+
+# State record rules (MS-EMF 2.3.11): fixed sizes, enumeration domains, nonzero
+# divisors, RESTOREDC sign, and the length fields of the profile and UFI records.
+return if Emf::Conformance::Registry.loaded_elsewhere?(__FILE__)
+
+module Emf
+  module Conformance
+    module StateRules
+      EMF = %i[emf emf_plus].freeze
+
+      # type => Size the record section states ("This value is 0x...").
+      STATED_SIZE = { 16 => 12, 23 => 32, 34 => 12, 57 => 12, 98 => 12, 115 => 12 }.freeze
+      # type => Size implied by a record that has fixed fields only (no Size value is stated).
+      LAYOUT_SIZE = { 9 => 16, 10 => 16, 11 => 16, 12 => 16, 13 => 16, 17 => 12, 18 => 12, 19 => 12, 20 => 12, 21 => 12,
+                      22 => 12, 24 => 12, 25 => 12, 27 => 16, 31 => 24, 32 => 24, 33 => 8, 52 => 8, 58 => 12, 104 => 48,
+                      109 => 16, 120 => 16 }.freeze
+      # Types whose Size BELOW the layout is the error emf.opaque.fixed_size (any record, decoded or Raw); this table
+      # then only speaks of a Size above it, as a warning.
+      SHORT_BY_OPAQUE = [104, 109].freeze
+      SECTION = { 9 => "2.3.11.30", 10 => "2.3.11.31", 11 => "2.3.11.28", 12 => "2.3.11.29", 13 => "2.3.11.12",
+                  16 => "2.3.11.20", 17 => "2.3.11.19", 18 => "2.3.11.11", 19 => "2.3.11.22", 20 => "2.3.11.23",
+                  21 => "2.3.11.24", 22 => "2.3.11.25", 23 => "2.3.11.13", 24 => "2.3.11.26", 25 => "2.3.11.10",
+                  27 => "2.3.11.4", 31 => "2.3.11.7", 32 => "2.3.11.8", 33 => "2.3.11", 34 => "2.3.11.6",
+                  52 => "2.3.11", 57 => "2.3.11.9", 58 => "2.3.11.21", 98 => "2.3.11.14", 104 => "2.3.11.5",
+                  109 => "2.3.11.2", 115 => "2.3.11.17", 120 => "2.3.11.27" }.freeze
+
+      TEXT_ALIGN_MASK = 0x11F # TA_UPDATECP, horizontal 0x6, vertical 0x18, TA_RTLREADING
+      HORIZONTAL_ALIGN = [0, 2, 6].freeze # TA_LEFT, TA_RIGHT, TA_CENTER
+      VERTICAL_ALIGN = [0, 8, 24].freeze # TA_TOP, TA_BOTTOM, TA_BASELINE
+      LAYOUT_BITS = 0x9 # LAYOUT_RTL, LAYOUT_BITMAPORIENTATIONPRESERVED (LAYOUT_LTR is 0)
+
+      TEXT_ALIGN_SWEEP = "spec/fixtures/emf test-039 and test-040 write every alignment value 0x0..0x16, including the " \
+                         "undefined 0x4, 0x10 and combinations of them; each component is still read from its own bits"
+
+      # rule id => [type, wire field, valid?, enumeration label, record section, severity, tolerant reason]
+      ENUMS = {
+        "emf.state.map_mode" => [17, :map_mode, (1..8).method(:cover?), "MapMode (MM_TEXT..MM_ANISOTROPIC, 1..8)", "2.3.11.19", :error],
+        "emf.state.bk_mode" => [18, :bk_mode, (1..2).method(:cover?), "BackgroundMode (TRANSPARENT 1, OPAQUE 2)", "2.3.11.11", :error],
+        "emf.state.poly_fill_mode" => [19, :poly_fill_mode, (1..2).method(:cover?), "PolygonFillMode (ALTERNATE 1, WINDING 2)",
+                                       "2.3.11.22", :error],
+        "emf.state.rop2" => [20, :rop2, (1..16).method(:cover?), "Binary Raster Op (R2_BLACK..R2_WHITE, 1..16)", "2.3.11.23", :error],
+        "emf.state.stretch_mode" => [21, :stretch_mode, (1..4).method(:cover?), "StretchMode (1..4); the record says MAY", "2.3.11.24",
+                                     :warning],
+        "emf.state.arc_direction" => [57, :arc_direction, (1..2).method(:cover?), "ArcDirection (AD_COUNTERCLOCKWISE 1, AD_CLOCKWISE 2)",
+                                      "2.3.11.9", :error],
+        "emf.state.icm_mode" => [98, :mode, (1..4).method(:cover?), "ICMMode (ICM_OFF..ICM_DONE_OUTSIDEDC, 1..4)", "2.3.11.14", :error],
+        "emf.state.layout_mode" => [115, :mode, lambda { |v|
+          v.nobits?(~LAYOUT_BITS)
+        }, "LayoutMode flags (0x0, 0x1, 0x8)", "2.3.11.17", :error],
+        "emf.state.mapper_flags" => [16, :flags, [0, 1].method(:include?), "font mapper Flags (0 or 1)", "2.3.11.20", :warning],
+        "emf.state.text_align" => [22, :text_align_mode, lambda { |v|
+          v.nobits?(~TEXT_ALIGN_MASK) && HORIZONTAL_ALIGN.include?(v & 0x6) && VERTICAL_ALIGN.include?(v & 0x18)
+        }, "TextAlignmentMode flags (one horizontal and one vertical value, optional TA_UPDATECP and TA_RTLREADING)", "2.3.11.25", :error,
+                                   TEXT_ALIGN_SWEEP]
+      }.freeze
+
+      # rule id => [type, [wire fields], record section]
+      NONZERO = {
+        "emf.state.scale_viewport_ext" => [31, %i[x_num x_denom y_num y_denom], "2.3.11.7"],
+        "emf.state.scale_window_ext" => [32, %i[x_num x_denom y_num y_denom], "2.3.11.8"]
+      }.freeze
+
+      # type => [name field/prefix bytes, record section] for the cbName + cbData profile payload.
+      PROFILE = { 112 => [12, "2.3.11.15"], 113 => [12, "2.3.11.16"], 121 => [16, "2.3.11.1"] }.freeze
+
+      module_function
+
+      def each_wire(context, types)
+        context.records.each_with_index do |record, index|
+          next unless types.include?(context.record_type(record))
+
+          wire = record.wire
+          yield(record, index, wire) if wire.is_a?(Emf::Emr::Binary::Record)
+        end
+      end
+
+      def at(record, index, message)
+        { message: message, offset: record.offset, record_index: index + 1, record_type: record.type_id.to_i }
+      end
+
+      def size_findings(context, table, label)
+        found = []
+        each_wire(context, table.keys) do |record, index, _wire|
+          type = context.record_type(record)
+          size = context.record_size(record)
+          next if size == table.fetch(type)
+          next if size < table.fetch(type) && table.equal?(LAYOUT_SIZE) && SHORT_BY_OPAQUE.include?(type)
+
+          found << at(record, index, "#{RecordTypes.name(type)} (#{SECTION.fetch(type)}) Size is #{size}, #{label} #{table.fetch(type)}")
+        end
+        found
+      end
+
+      def fixed_size(context) = size_findings(context, STATED_SIZE, "the record section states")
+
+      def layout_size(context) = size_findings(context, LAYOUT_SIZE, "its fixed fields occupy")
+
+      def enum_check(context, id)
+        type, field, valid, label, section, = ENUMS.fetch(id)
+        found = []
+        each_wire(context, [type]) do |record, index, wire|
+          value = wire.public_send(field).to_i
+          next if valid.call(value)
+
+          found << at(record, index, "#{RecordTypes.name(type)} (#{section}) #{field} 0x#{value.to_s(16)} is not a valid #{label}")
+        end
+        found
+      end
+
+      def nonzero(context, id)
+        type, fields, section = NONZERO.fetch(id)
+        found = []
+        each_wire(context, [type]) do |record, index, wire|
+          zero = fields.select { |field| wire.public_send(field).to_i.zero? }
+          next if zero.empty?
+
+          found << at(record, index, "#{RecordTypes.name(type)} (#{section}) #{zero.join(', ')} MUST NOT be zero")
+        end
+        found
+      end
+
+      def restoredc_negative(context)
+        found = []
+        each_wire(context, [34]) do |record, index, wire|
+          saved = wire.saved_dc.to_i
+          found << at(record, index, "EMR_RESTOREDC SavedDC is #{saved}, MUST be negative") unless saved.negative?
+        end
+        found
+      end
+
+      def color_adjustment(context)
+        found = []
+        each_wire(context, [23]) do |record, index, wire|
+          # A body under 24 bytes is a Size under 32: emf.state.fixed_size already reports that.
+          next if wire.body.to_s.bytesize < 24
+
+          size = wire.adjustment_size
+          found << at(record, index, "ColorAdjustment Size is #{size}, MUST be 0x0018") unless size == 24
+          index_value = wire.illuminant_index
+          if index_value > 8
+            found << at(record, index,
+                        "ColorAdjustment IlluminantIndex #{index_value} is not in the Illuminant enumeration (0..8)")
+          end
+        end
+        found
+      end
+
+      def pixel_format_version(context)
+        found = []
+        each_wire(context, [104]) do |record, index, wire|
+          next if wire.body.to_s.bytesize < 40
+
+          version = wire.pfd_version
+          found << at(record, index, "PixelFormatDescriptor nVersion is #{version}, MUST be 1") unless version == 1
+        end
+        found
+      end
+
+      def color_match_target(context)
+        found = []
+        each_wire(context, [121]) do |record, index, wire|
+          next if wire.body.to_s.bytesize < 16
+
+          unless (1..3).cover?(wire.dw_action)
+            found << at(record, index,
+                        "EMR_COLORMATCHTOTARGETW dwAction #{wire.dw_action} is not in the ColorSpace enumeration (1..3)")
+          end
+          unless (0..1).cover?(wire.dw_flags)
+            found << at(record, index,
+                        "EMR_COLORMATCHTOTARGETW dwFlags #{wire.dw_flags} is not in the ColorMatchToTarget enumeration (0..1)")
+          end
+        end
+        found
+      end
+
+      def profile_bounds(context)
+        found = []
+        each_wire(context, PROFILE.keys) do |record, index, wire|
+          prefix, section = PROFILE.fetch(context.record_type(record))
+          body = wire.body.to_s.bytesize
+          name = RecordTypes.name(context.record_type(record))
+          if body < prefix
+            next found << at(record, index,
+                             "#{name} (#{section}) holds #{body} bytes after Size, fewer than its #{prefix}-byte fixed part")
+          end
+
+          need = prefix + wire.cb_name + wire.cb_data
+          next unless need > body
+
+          found << at(record, index,
+                      "#{name} (#{section}) cbName #{wire.cb_name} + cbData #{wire.cb_data} need #{need} bytes after Size, " \
+                      "the record holds #{body}")
+        end
+        found
+      end
+
+      def linked_ufis_bounds(context)
+        found = []
+        each_wire(context, [119]) do |record, index, wire|
+          body = wire.body.to_s.bytesize
+          next found << at(record, index, "EMR_SETLINKEDUFIS holds #{body} bytes after Size, fewer than uNumLinkedUFI") if body < 4
+
+          count = wire.u_num_linked_ufi
+          need = 12 + (count * 8) # uNumLinkedUFI + ufis + 8 reserved bytes
+          if need > body
+            found << at(record, index,
+                        "EMR_SETLINKEDUFIS (2.3.11.18) uNumLinkedUFI #{count} needs #{need} bytes after Size, the record holds #{body}")
+          end
+        end
+        found
+      end
+    end
+
+    registry = Registry.loading
+    state = StateRules::EMF
+
+    registry.register(id: "emf.state.fixed_size", formats: state, citation: "MS-EMF 2.3.11", kind: :fixed_size, severity: :error) do |c|
+      StateRules.fixed_size(c)
+    end
+    registry.register(id: "emf.state.layout_size", formats: state, citation: "MS-EMF 2.3.11", kind: :layout_size, severity: :warning) do |c|
+      StateRules.layout_size(c)
+    end
+    StateRules::ENUMS.each do |id, (_type, _field, _valid, _label, section, severity, reason)|
+      registry.register(id: id, formats: state, citation: "MS-EMF #{section}", kind: id.split(".").last.to_sym, severity: severity,
+                        tolerant_reason: reason) do |c|
+        StateRules.enum_check(c, id)
+      end
+    end
+    StateRules::NONZERO.each do |id, (_type, _fields, section)|
+      registry.register(id: id, formats: state, citation: "MS-EMF #{section}", kind: :nonzero_divisor) { |c| StateRules.nonzero(c, id) }
+    end
+    {
+      "emf.state.restoredc_negative" => [:restoredc_negative, "MS-EMF 2.3.11.6", :saved_dc],
+      "emf.state.color_adjustment" => [:color_adjustment, "MS-EMF 2.2.2", :color_adjustment],
+      "emf.state.pixel_format_version" => [:pixel_format_version, "MS-EMF 2.2.22", :pixel_format_version],
+      "emf.state.color_match_target" => [:color_match_target, "MS-EMF 2.3.11.1", :color_match_target],
+      "emf.state.profile_bounds" => [:profile_bounds, "MS-EMF 2.3.11.15", :profile_bounds],
+      "emf.state.linked_ufis_bounds" => [:linked_ufis_bounds, "MS-EMF 2.3.11.18", :linked_ufis_bounds]
+    }.each do |id, (method, citation, kind)|
+      registry.register(id: id, formats: state, citation: citation, kind: kind) { |c| StateRules.public_send(method, c) }
+    end
+  end
+end

data/lib/emf/conformance/rules/emf_text.rb

@@ -0,0 +1,221 @@
+# frozen_string_literal: true
+
+# Text output rules (MS-EMF 2.2.5 EmrText, 2.3.5.7/.8 EXTTEXTOUT, 2.3.5.32/.33 POLYTEXTOUT,
+# 2.3.5.37 SMALLTEXTOUT). Offsets, counts and option bits are read from the record's own
+# bytes; the characters themselves are never decoded.
+return if Emf::Conformance::Registry.loaded_elsewhere?(__FILE__)
+
+module Emf
+  module Conformance
+    module TextRules
+      EMF = %i[emf emf_plus].freeze
+      ETO_PDY = 0x2000
+      ETO_GLYPH_INDEX = 0x10
+      ETO_NO_RECT = 0x100
+      ETO_SMALL_CHARS = 0x200
+      # ExtTextOutOptions (MS-EMF 2.1.11).
+      DEFINED_OPTIONS = [0x2, 0x4, 0x10, 0x80, 0x100, 0x200, 0x400, 0x800, 0x1000, 0x2000, 0x10000].sum.freeze
+
+      # type => [name, wide characters?]
+      EXT = { 83 => ["EMR_EXTTEXTOUTA", false], 84 => ["EMR_EXTTEXTOUTW", true] }.freeze
+      POLY = { 96 => ["EMR_POLYTEXTOUTA", false], 97 => ["EMR_POLYTEXTOUTW", true] }.freeze
+      SMALL = 108
+      EXT_TEXT_AT = 36
+      POLY_TABLE_AT = 40
+      UNREADABLE = "the record Size still delimits the stream, so a string or Dx array that cannot be located is skipped by readers"
+
+      # id => [citation, kind, severity, tolerant_reason]
+      RULES = {
+        "emf.exttextout.string_bounds" => ["MS-EMF 2.2.5", :string_bounds, :error, UNREADABLE],
+        "emf.exttextout.string_offset_alignment" => ["MS-EMF 2.2.5", :string_alignment, :error, nil],
+        "emf.exttextout.dx_bounds" => ["MS-EMF 2.2.5", :dx_bounds, :error, UNREADABLE],
+        "emf.exttextout.dx_offset_alignment" => ["MS-EMF 2.2.5", :dx_alignment, :error, nil],
+        "emf.exttextout.options_defined" => ["MS-EMF 2.1.11", :exttextout_options, :warning, nil],
+        "emf.exttextout.string_encoding" => ["MS-EMF 2.2.5", :string_encoding, :error,
+                                             "readers decode a damaged UTF-16LE string character by character and still draw the rest"],
+        "emf.smalltextout.text_string" => ["MS-EMF 2.3.5.37", :small_text, :error, UNREADABLE],
+        "emf.smalltextout.options_defined" => ["MS-EMF 2.1.11", :smalltextout_options, :warning, nil],
+        "emf.polytextout.strings" => ["MS-EMF 2.3.5.32", :poly_strings, :error, UNREADABLE],
+        "emf.polytextout.dx" => ["MS-EMF 2.3.5.32", :poly_dx, :error, UNREADABLE],
+        "emf.polytextout.options_defined" => ["MS-EMF 2.1.11", :polytextout_options, :warning, nil],
+        "emf.opaque.text_arrays" => ["MS-EMF 2.3.5.32", :poly_table, :error, UNREADABLE]
+      }.freeze
+
+      # Findings of one metafile, grouped by rule id; computed once and shared by all rules.
+      CACHE = ObjectSpace::WeakMap.new
+
+      module_function
+
+      def findings(context, id)
+        # The WeakMap holds its values weakly: keep a strong reference until the lookup is done.
+        grouped = CACHE[context] || (CACHE[context] = analyze(context))
+        grouped.fetch(id, [])
+      end
+
+      def analyze(context)
+        out = Hash.new { |hash, id| hash[id] = [] }
+        context.records.each_with_index do |record, index|
+          type = context.record_type(record)
+          next unless EXT.key?(type) || POLY.key?(type) || type == SMALL
+
+          Scan.new(record, index, context.record_size(record), out).run(type)
+        end
+        out
+      end
+
+      # Option, string and Dx checks shared by the EXTTEXTOUT and POLYTEXTOUT descriptors; mixed into Scan.
+      module BufferChecks
+        private
+
+        def check_options(id, label, options)
+          undefined = options & ~DEFINED_OPTIONS
+          return if undefined.zero?
+
+          add(id,
+              format("%<label>s Options 0x%<options>X sets bits outside ExtTextOutOptions (0x%<bits>X)",
+                     label: label, options: options, bits: undefined))
+        end
+
+        def check_string(label, entry, wide, fixed_end, bounds_id, alignment_id)
+          width = wide ? 2 : 1
+          length = entry[:chars] * width
+          return if entry[:chars].zero?
+
+          if entry[:off_string] < fixed_end || entry[:off_string] + length > @size
+            add(bounds_id,
+                "#{label} string of #{entry[:chars]} chars at #{entry[:off_string]} is outside the record body (#{fixed_end}..#{@size})")
+          elsif (entry[:off_string] % width).positive?
+            add(alignment_id, "#{label} offString #{entry[:off_string]} is not #{width * 8}-bit aligned")
+          elsif wide && entry[:options].nobits?(ETO_GLYPH_INDEX) # glyph indexes are arbitrary 16-bit codes, not UTF-16
+            check_encoding(label, entry, length)
+          end
+        end
+
+        # UTF16-LE: an unpaired surrogate is not a character (MS-EMF 2.2.5, OutputString).
+        def check_encoding(label, entry, length)
+          text = @bytes.byteslice(entry[:off_string], length).force_encoding(Encoding::UTF_16LE)
+          return if text.valid_encoding?
+
+          add("emf.exttextout.string_encoding",
+              "#{label} string at offset #{entry[:off_string]} is not valid UTF-16LE (unpaired surrogate)")
+        end
+
+        def check_dx(label, entry, fixed_end, bounds_id, alignment_id)
+          return if entry[:chars].zero? || entry[:off_dx].zero?
+
+          length = entry[:chars] * (entry[:options].anybits?(ETO_PDY) ? 2 : 1) * 4
+          if entry[:off_dx] < fixed_end || entry[:off_dx] + length > @size
+            add(bounds_id,
+                "#{label} Dx array of #{length / 4} values at #{entry[:off_dx]} is outside the record body (#{fixed_end}..#{@size})")
+          elsif (entry[:off_dx] % 4).positive?
+            add(alignment_id, "#{label} offDx #{entry[:off_dx]} is not 32-bit aligned")
+          end
+        end
+      end
+
+      # One record's checks; every method adds to `out[rule id]`.
+      class Scan
+        include BufferChecks
+
+        def initialize(record, index, size, out)
+          @record = record
+          @index = index
+          @out = out
+          @bytes = record.to_binary_s
+          @size = [size.to_i, @bytes.bytesize].min
+        end
+
+        def run(type)
+          if EXT.key?(type)
+            ext_text(*EXT.fetch(type))
+          elsif POLY.key?(type)
+            poly_text(*POLY.fetch(type))
+          else
+            small_text
+          end
+        end
+
+        private
+
+        def add(id, message)
+          @out[id] << { message: message, offset: @record.offset, record_index: @index + 1, record_type: @record.type_id.to_i }
+        end
+
+        def u32(pos) = @bytes.unpack1("V", offset: pos)
+
+        # EmrText fixed part: Reference, Chars, offString, Options, [Rectangle], offDx.
+        # offDx is nil when the record ends before it; callers check `length` first.
+        def text_entry(start)
+          options = u32(start + 16)
+          length = options.anybits?(ETO_NO_RECT) ? 24 : 40
+          off_dx = u32(start + length - 4) if start + length <= @bytes.bytesize
+          { chars: u32(start + 8), off_string: u32(start + 12), options: options, off_dx: off_dx, length: length }
+        end
+
+        def ext_text(name, wide)
+          return unless @size >= EXT_TEXT_AT + 24
+
+          entry = text_entry(EXT_TEXT_AT)
+          if @size < EXT_TEXT_AT + entry[:length]
+            return add("emf.exttextout.string_bounds",
+                       "#{name} is shorter than its #{EXT_TEXT_AT + entry[:length]}-byte EmrText fixed part")
+          end
+
+          check_options("emf.exttextout.options_defined", name, entry[:options])
+          check_string(name, entry, wide, EXT_TEXT_AT + entry[:length], "emf.exttextout.string_bounds",
+                       "emf.exttextout.string_offset_alignment")
+          check_dx(name, entry, EXT_TEXT_AT + entry[:length], "emf.exttextout.dx_bounds", "emf.exttextout.dx_offset_alignment")
+        end
+
+        def poly_text(name, wide)
+          entries = poly_table(name) or return
+
+          entries.each_with_index do |entry, i|
+            label = "#{name} string #{i}"
+            check_options("emf.polytextout.options_defined", label, entry[:options])
+            check_string(label, entry, wide, @table_end, "emf.polytextout.strings", "emf.polytextout.strings")
+            check_dx(label, entry, @table_end, "emf.polytextout.dx", "emf.polytextout.dx")
+          end
+        end
+
+        # cStrings descriptors, each 24 bytes (ETO_NO_RECT) or 40, must fit in the record; nil when they do not.
+        def poly_table(name)
+          count = u32(POLY_TABLE_AT - 4) if @size >= POLY_TABLE_AT
+          unless count
+            add("emf.opaque.text_arrays", "#{name} Size #{@size} is smaller than its 40-byte fixed part")
+            return nil
+          end
+
+          @table_end = POLY_TABLE_AT
+          (0...count).map do |i|
+            length = @table_end + 24 <= @size && (u32(@table_end + 16).anybits?(ETO_NO_RECT) ? 24 : 40)
+            if !length || @table_end + length > @size
+              add("emf.opaque.text_arrays", "#{name} cStrings #{count} descriptors run past the record at descriptor #{i}")
+              return nil
+            end
+
+            text_entry(@table_end).tap { @table_end += length }
+          end
+        end
+
+        def small_text
+          return unless @size >= 36
+
+          options = u32(20)
+          check_options("emf.smalltextout.options_defined", "EMR_SMALLTEXTOUT", options)
+          start = options.anybits?(ETO_NO_RECT) ? 36 : 52
+          length = u32(16) * (options.anybits?(ETO_SMALL_CHARS) ? 1 : 2)
+          return unless start + length > @size
+
+          add("emf.smalltextout.text_string",
+              "EMR_SMALLTEXTOUT TextString of #{length} bytes at offset #{start} runs past the #{@size}-byte record")
+        end
+      end
+    end
+
+    TextRules::RULES.each do |id, (citation, kind, severity, reason)|
+      Registry.loading.register(id: id, formats: TextRules::EMF, citation: citation, kind: kind, severity: severity,
+                                tolerant_reason: reason) { |context| TextRules.findings(context, id) }
+    end
+  end
+end

data/lib/emf/conformance/rules/emf_transform.rb

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+# Transform record rules (MS-EMF 2.3.12, 2.2.28): fixed sizes, the
+# ModifyWorldTransformMode enumeration and the XForm matrix values.
+return if Emf::Conformance::Registry.loaded_elsewhere?(__FILE__)
+
+module Emf
+  module Conformance
+    module TransformRules
+      EMF = %i[emf emf_plus].freeze
+      SET_WORLD = 35
+      MODIFY_WORLD = 36
+      STATED_SIZE = { SET_WORLD => 32, MODIFY_WORLD => 36 }.freeze
+      MATRIX_FIELDS = %i[m11 m12 m21 m22 dx dy].freeze
+      MWT_IDENTITY = 1
+
+      module_function
+
+      def each_wire(context)
+        context.records.each_with_index do |record, index|
+          next unless STATED_SIZE.key?(context.record_type(record))
+
+          wire = record.wire
+          yield(record, index, wire) if wire.is_a?(Emf::Emr::Binary::Record)
+        end
+      end
+
+      def at(record, index, message)
+        { message: message, offset: record.offset, record_index: index + 1, record_type: record.type_id.to_i }
+      end
+
+      def fixed_size(context)
+        found = []
+        each_wire(context) do |record, index, _wire|
+          type = context.record_type(record)
+          size = context.record_size(record)
+          next if size == STATED_SIZE.fetch(type)
+
+          found << at(record, index, "#{RecordTypes.name(type)} Size is #{size}, the record section states #{STATED_SIZE.fetch(type)}")
+        end
+        found
+      end
+
+      def modify_mode(context)
+        found = []
+        each_wire(context) do |record, index, wire|
+          next unless context.record_type(record) == MODIFY_WORLD
+
+          mode = wire.modify_mode.to_i
+          next if (1..4).cover?(mode)
+
+          found << at(record, index,
+                      "EMR_MODIFYWORLDTRANSFORM ModifyWorldTransformMode #{mode} is not in the enumeration (MWT_IDENTITY..MWT_SET, 1..4)")
+        end
+        found
+      end
+
+      # MWT_IDENTITY ignores the transform data, so its matrix is not inspected.
+      def finite_matrix(context)
+        found = []
+        each_wire(context) do |record, index, wire|
+          next if context.record_type(record) == MODIFY_WORLD && wire.modify_mode.to_i == MWT_IDENTITY
+
+          bad = MATRIX_FIELDS.reject { |field| wire.xform.public_send(field).to_f.finite? }
+          next if bad.empty?
+
+          found << at(record, index, "#{RecordTypes.name(context.record_type(record))} XForm #{bad.join(', ')} is not a finite number")
+        end
+        found
+      end
+    end
+
+    registry = Registry.loading
+    transform = TransformRules::EMF
+    registry.register(id: "emf.transform.fixed_size", formats: transform, citation: "MS-EMF 2.3.12", kind: :fixed_size) do |c|
+      TransformRules.fixed_size(c)
+    end
+    registry.register(id: "emf.transform.modify_mode", formats: transform, citation: "MS-EMF 2.3.12.1", kind: :modify_mode) do |c|
+      TransformRules.modify_mode(c)
+    end
+    # The XForm section defines six FLOAT values and states no finiteness requirement.
+    registry.register(id: "emf.transform.finite_matrix", formats: transform, citation: "MS-EMF 2.2.28", kind: :finite_matrix,
+                      severity: :warning) { |c| TransformRules.finite_matrix(c) }
+  end
+end