emf 0.1.2 → 0.2.0

data/lib/emf/conformance.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module Emf
+  # Conformance lens: checks a parsed metafile against the Microsoft specs and
+  # reports structured diagnostics in svg_conform's report shape.
+  #
+  #   Emf::Conformance.check("file.emf", profile: :tolerant).to_h
+  #
+  # Rules read only the public model API (records, wire fields, Metafile#errors,
+  # Metafile#emf_plus_stream); they never touch a backend-specific class.
+  module Conformance
+    autoload :Diagnostic, "emf/conformance/diagnostic"
+    autoload :Report, "emf/conformance/report"
+    autoload :Profile, "emf/conformance/profile"
+    autoload :Rule, "emf/conformance/rule"
+    autoload :Registry, "emf/conformance/registry"
+    autoload :Context, "emf/conformance/context"
+    autoload :Runner, "emf/conformance/runner"
+    autoload :RecordTypes, "emf/conformance/record_types"
+    autoload :Manifest, "emf/conformance/manifest"
+    autoload :TernaryRasterOperations, "emf/conformance/ternary_raster_operations"
+
+    # @param input [String, Pathname, Emf::Model::Metafile] a file path, raw bytes or a parsed metafile
+    # @param profile [Symbol] :strict (spec-conformant only) or :tolerant (accepts the real-world corpus)
+    # @param registry [Registry] rule set; defaults to every rule file under conformance/rules
+    # @return [Report]
+    def self.check(input, profile: :strict, registry: Registry.default, now: Time.now)
+      Runner.new(Profile.fetch(profile), registry).call(input, now: now)
+    end
+  end
+end

data/lib/emf/emf_plus/effects/blur.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+require "emf/binary/float32_le"
+
+module Emf
+  module EmfPlus
+    module Effects
+      # BlurEffect (2.2.3.1).
+      class Blur < Effect
+        GUID = "633c80a4-1843-482b-9ef2-be2834c5fdd4"
+
+        class BlurBody < Records::Body
+          endian :little
+          float32_le :blur_radius
+          uint32 :expand_edge
+        end
+        BODY = BlurBody
+
+        def blur_radius = body.blur_radius
+        def expand_edge = body.expand_edge
+      end
+    end
+  end
+end

data/lib/emf/emf_plus/effects/brightness_contrast.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Emf
+  module EmfPlus
+    module Effects
+      # BrightnessContrastEffect (2.2.3.2).
+      class BrightnessContrast < Effect
+        GUID = "d3a1dbe1-8ec4-4c17-9f4c-ea97ad1c343d"
+
+        class BrightnessContrastBody < Records::Body
+          endian :little
+          int32 :brightness_level
+          int32 :contrast_level
+        end
+        BODY = BrightnessContrastBody
+
+        def brightness_level = body.brightness_level
+        def contrast_level = body.contrast_level
+      end
+    end
+  end
+end

data/lib/emf/emf_plus/effects/color_balance.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Emf
+  module EmfPlus
+    module Effects
+      # ColorBalanceEffect (2.2.3.3).
+      class ColorBalance < Effect
+        GUID = "537e597d-251e-48da-9664-29ca496b70f8"
+
+        class ColorBalanceBody < Records::Body
+          endian :little
+          int32 :cyan_red
+          int32 :magenta_green
+          int32 :yellow_blue
+        end
+        BODY = ColorBalanceBody
+
+        def cyan_red = body.cyan_red
+        def magenta_green = body.magenta_green
+        def yellow_blue = body.yellow_blue
+      end
+    end
+  end
+end

data/lib/emf/emf_plus/effects/color_curve.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Emf
+  module EmfPlus
+    module Effects
+      # ColorCurveEffect (2.2.3.4).
+      class ColorCurve < Effect
+        GUID = "dd6a0022-58e4-4a67-9d9b-d48eb881a53d"
+
+        class ColorCurveBody < Records::Body
+          endian :little
+          uint32 :curve_adjustment
+          uint32 :curve_channel
+          int32 :adjustment_intensity
+        end
+        BODY = ColorCurveBody
+
+        def curve_adjustment = body.curve_adjustment
+        def curve_channel = body.curve_channel
+        def adjustment_intensity = body.adjustment_intensity
+      end
+    end
+  end
+end

data/lib/emf/emf_plus/effects/color_lookup_table.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module Emf
+  module EmfPlus
+    module Effects
+      # ColorLookupTableEffect (2.2.3.5).
+      class ColorLookupTable < Effect
+        GUID = "a7ce72a9-0f7f-40d7-b3cc-d0c02d5c3212"
+
+        class ColorLookupTableBody < Records::Body
+          endian :little
+          string :blue_lookup_table, length: 256
+          string :green_lookup_table, length: 256
+          string :red_lookup_table, length: 256
+          string :alpha_lookup_table, length: 256
+        end
+        BODY = ColorLookupTableBody
+
+        def blue_lookup_table = body.blue_lookup_table.to_s
+        def green_lookup_table = body.green_lookup_table.to_s
+        def red_lookup_table = body.red_lookup_table.to_s
+        def alpha_lookup_table = body.alpha_lookup_table.to_s
+      end
+    end
+  end
+end

data/lib/emf/emf_plus/effects/color_matrix.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+require "emf/binary/float32_le"
+
+module Emf
+  module EmfPlus
+    module Effects
+      # ColorMatrixEffect (2.2.3.6).
+      class ColorMatrix < Effect
+        GUID = "718f2615-7933-40e3-a511-5f68fe14dd74"
+
+        class ColorMatrixBody < Records::Body
+          endian :little
+          array :matrix_values, type: :float32_le, initial_length: 25
+        end
+        BODY = ColorMatrixBody
+
+        # Matrix[row][column]; the spec lists each column's five rows in turn.
+        def matrix = Array.new(5) { |row| Array.new(5) { |column| body.matrix_values[(column * 5) + row] } }
+      end
+    end
+  end
+end

data/lib/emf/emf_plus/effects/effect.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+require "bindata"
+
+module Emf
+  module EmfPlus
+    module Effects
+      # An image effect parameter block read through a BinData class (BODY in
+      # the subclass). Bytes after the body stay in `trailing`, so an unedited
+      # effect re-encodes to its buffer.
+      class Effect
+        attr_reader :body, :trailing
+
+        def initialize(buffer, offset:, record_code:)
+          @buffer = buffer
+          @offset = offset
+          @record_code = record_code
+          check_bounds
+          @body = read_body
+          @trailing = buffer.byteslice(@body.num_bytes..).freeze
+        end
+
+        def to_binary = body.to_binary_s + trailing
+
+        private
+
+        attr_reader :buffer
+
+        def check_bounds; end
+
+        def read_body
+          self.class::BODY.new.read(buffer)
+        rescue IOError, BinData::ValidityError => e
+          fail_parse(e.message)
+        end
+
+        def fail_parse(message)
+          raise ParseError.new(offset: @offset, record_code: @record_code,
+                               message: "malformed #{self.class.name.split('::').last} effect at offset #{@offset}: #{message}")
+        end
+
+        def require_room(needed, what)
+          return if needed <= buffer.bytesize
+
+          fail_parse("#{what} needs #{needed} bytes, buffer holds #{buffer.bytesize}")
+        end
+      end
+    end
+  end
+end

data/lib/emf/emf_plus/effects/hue_saturation_lightness.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Emf
+  module EmfPlus
+    module Effects
+      # HueSaturationLightnessEffect (2.2.3.7).
+      class HueSaturationLightness < Effect
+        GUID = "8b2dd6c3-eb07-4d87-a5f0-7108e26a9c5f"
+
+        class HueSaturationLightnessBody < Records::Body
+          endian :little
+          int32 :hue_level
+          int32 :saturation_level
+          int32 :lightness_level
+        end
+        BODY = HueSaturationLightnessBody
+
+        def hue_level = body.hue_level
+        def saturation_level = body.saturation_level
+        def lightness_level = body.lightness_level
+      end
+    end
+  end
+end

data/lib/emf/emf_plus/effects/levels.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Emf
+  module EmfPlus
+    module Effects
+      # LevelsEffect (2.2.3.8).
+      class Levels < Effect
+        GUID = "99c354ec-2a31-4f3a-8c34-17a803b33a25"
+
+        class LevelsBody < Records::Body
+          endian :little
+          int32 :highlight
+          int32 :mid_tone
+          int32 :shadow
+        end
+        BODY = LevelsBody
+
+        def highlight = body.highlight
+        def mid_tone = body.mid_tone
+        def shadow = body.shadow
+      end
+    end
+  end
+end

data/lib/emf/emf_plus/effects/opaque.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Emf
+  module EmfPlus
+    module Effects
+      # A parameter block of an unknown GUID, or a ColorCurve block that does
+      # not fit its layout (Windows writes those corrupt, ch05 note 10).
+      class Opaque
+        attr_reader :buffer
+
+        def initialize(buffer)
+          @buffer = buffer
+        end
+
+        def to_binary = buffer
+      end
+    end
+  end
+end

data/lib/emf/emf_plus/effects/red_eye_correction.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module Emf
+  module EmfPlus
+    module Effects
+      # RedEyeCorrectionEffect (2.2.3.9): NumberOfAreas WMF RectL objects, read with
+      # the core Emf::Binary::Types::RectL (a nested RectL would replace it in
+      # BinData's global registry).
+      class RedEyeCorrection < Effect
+        GUID = "74d29d05-69a4-4266-9549-3cc52836b632"
+        RECT_SIZE = 16
+
+        class RedEyeCorrectionBody < Records::Body
+          endian :little
+          int32 :number_of_areas
+          array :areas, type: :rect_l, initial_length: :number_of_areas
+        end
+        BODY = RedEyeCorrectionBody
+
+        def number_of_areas = body.number_of_areas
+        def areas = body.areas.map { |r| [r.left, r.top, r.right, r.bottom] }
+
+        private
+
+        def check_bounds
+          return if buffer.bytesize < 4
+
+          count = buffer.unpack1("l<")
+          fail_parse("negative NumberOfAreas #{count}") if count.negative?
+          require_room(4 + (count * RECT_SIZE), "Areas of #{count} rectangles")
+        end
+      end
+    end
+  end
+end

data/lib/emf/emf_plus/effects/sharpen.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+require "emf/binary/float32_le"
+
+module Emf
+  module EmfPlus
+    module Effects
+      # SharpenEffect (2.2.3.10).
+      class Sharpen < Effect
+        GUID = "63cbf3ee-c526-402c-8f71-62c540bf5142"
+
+        class SharpenBody < Records::Body
+          endian :little
+          float32_le :radius
+          float32_le :amount
+        end
+        BODY = SharpenBody
+
+        def radius = body.radius
+        def amount = body.amount
+      end
+    end
+  end
+end

data/lib/emf/emf_plus/effects/tint.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Emf
+  module EmfPlus
+    module Effects
+      # TintEffect (2.2.3.11).
+      class Tint < Effect
+        GUID = "1077af00-2848-4441-9489-44ad4c2d7a2c"
+
+        class TintBody < Records::Body
+          endian :little
+          int32 :hue
+          int32 :amount
+        end
+        BODY = TintBody
+
+        def hue = body.hue
+        def amount = body.amount
+      end
+    end
+  end
+end

data/lib/emf/emf_plus/effects.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module Emf
+  module EmfPlus
+    # Typed image effect parameter blocks (2.2.3), identified by the GUID of
+    # the EmfPlusSerializableObject that carries them.
+    module Effects
+      autoload :Effect, "emf/emf_plus/effects/effect"
+      autoload :Opaque, "emf/emf_plus/effects/opaque"
+      autoload :Blur, "emf/emf_plus/effects/blur"
+      autoload :BrightnessContrast, "emf/emf_plus/effects/brightness_contrast"
+      autoload :ColorBalance, "emf/emf_plus/effects/color_balance"
+      autoload :ColorCurve, "emf/emf_plus/effects/color_curve"
+      autoload :ColorLookupTable, "emf/emf_plus/effects/color_lookup_table"
+      autoload :ColorMatrix, "emf/emf_plus/effects/color_matrix"
+      autoload :HueSaturationLightness, "emf/emf_plus/effects/hue_saturation_lightness"
+      autoload :Levels, "emf/emf_plus/effects/levels"
+      autoload :RedEyeCorrection, "emf/emf_plus/effects/red_eye_correction"
+      autoload :Sharpen, "emf/emf_plus/effects/sharpen"
+      autoload :Tint, "emf/emf_plus/effects/tint"
+
+      CLASSES = %i[Blur BrightnessContrast ColorBalance ColorCurve ColorLookupTable ColorMatrix
+                   HueSaturationLightness Levels RedEyeCorrection Sharpen Tint].freeze
+      private_constant :CLASSES
+
+      module_function
+
+      # `serializable` is a Records::SerializableObject.
+      def decode(serializable)
+        klass = lookup(serializable.object_guid)
+        return Opaque.new(serializable.buffer) unless klass
+
+        klass.new(serializable.buffer, offset: serializable.offset, record_code: serializable.type)
+      rescue ParseError
+        raise unless klass == ColorCurve
+
+        Opaque.new(serializable.buffer)
+      end
+
+      def lookup(guid)
+        CLASSES.map { |name| const_get(name) }.find { |klass| guid == klass::GUID }
+      end
+    end
+  end
+end

data/lib/emf/emf_plus/frame.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module Emf
+  module EmfPlus
+    # One EMF+ record as framed on the wire: the 12-byte header fields plus the
+    # undecoded body. `data` is every byte after the header up to `size`, so a
+    # frame always re-serializes to the bytes it was read from.
+    #
+    # `offset` is the frame's position within its byte stream; `comment_index`
+    # is the index into Metafile#records of the EMR_COMMENT it was read from
+    # (nil when framed from a bare stream).
+    class Frame
+      HEADER_BYTES = 12
+
+      attr_reader :type, :flags, :size, :data_size, :data, :offset, :comment_index
+
+      def initialize(type:, flags:, size:, data_size:, data:, offset: 0, comment_index: nil)
+        @type = type
+        @flags = flags
+        @size = size
+        @data_size = data_size
+        @data = data.b.freeze
+        @offset = offset
+        @comment_index = comment_index
+        freeze
+      end
+
+      # Size must stay 32-bit aligned, so the body is zero-padded; DataSize keeps the real length.
+      def with_data(new_data)
+        padded = new_data.b + ("\0" * (-new_data.bytesize % 4))
+        self.class.new(type: type, flags: flags, size: HEADER_BYTES + padded.bytesize,
+                       data_size: new_data.bytesize, data: padded,
+                       offset: offset, comment_index: comment_index)
+      end
+
+      def to_binary
+        [type, flags, size, data_size].pack("vvVV") + data
+      end
+    end
+  end
+end

data/lib/emf/emf_plus/links/effect_link.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Emf
+  module EmfPlus
+    module Links
+      # An E-flag EmfPlusDrawImagePoints frame paired with the
+      # EmfPlusSerializableObject frame that supplies its effect.
+      EffectLink = Struct.new(:draw, :effect, keyword_init: true) do
+        def initialize(**)
+          super
+          freeze
+        end
+      end
+    end
+  end
+end

data/lib/emf/emf_plus/links/get_dc_span.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module Emf
+  module EmfPlus
+    module Links
+      # The EMF records a single EmfPlusGetDC makes drawable. `emr_range` indexes
+      # Metafile#records and is empty when another EMF+ record follows the GetDC.
+      GetDcSpan = Struct.new(:comment_index, :offset, :emr_range, keyword_init: true) do
+        def initialize(**)
+          super
+          freeze
+        end
+
+        def empty? = emr_range.none?
+      end
+    end
+  end
+end

data/lib/emf/emf_plus/links/link_error.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Emf
+  module EmfPlus
+    module Links
+      # A linking diagnostic. `reason` is :missing_effect or :non_adjacent_effect.
+      LinkError = Struct.new(:reason, :comment_index, :offset, :message, keyword_init: true) do
+        def initialize(**)
+          super
+          freeze
+        end
+      end
+    end
+  end
+end

data/lib/emf/emf_plus/links.rb

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+module Emf
+  module EmfPlus
+    # Ordering and linking rules that span EMF+ records and the EMF records
+    # around them. Works on framed records (Parser.from_metafile), never decodes
+    # or alters bytes, and reports problems instead of raising.
+    module Links
+      autoload :GetDcSpan, "emf/emf_plus/links/get_dc_span"
+      autoload :EffectLink, "emf/emf_plus/links/effect_link"
+      autoload :LinkError, "emf/emf_plus/links/link_error"
+
+      GET_DC = 0x4004
+      SERIALIZABLE_OBJECT = 0x4038
+      DRAW_IMAGE_POINTS = 0x401B
+      EFFECT_FLAG = 0x2000
+
+      module_function
+
+      # MS-EMFPLUS 2.3.3.2: EMF records are processed after an EmfPlusGetDC
+      # until the next EMF+ record. A GetDC that is not last in its comment is
+      # followed by an EMF+ record at once, so its span is empty; otherwise the
+      # span runs to the next comment carrying EMF+ records (or the end).
+      def get_dc_spans(metafile, frames)
+        frames.each_with_index.filter_map do |frame, index|
+          next unless frame.type == GET_DC
+
+          GetDcSpan.new(comment_index: frame.comment_index, offset: frame.offset,
+                        emr_range: emr_range_after(frames, index, metafile.records.size))
+        end
+      end
+
+      # MS-EMFPLUS 2.3.4.9 says an E-flag DrawImagePoints needs an "earlier"
+      # SerializableObject without saying how far back. Only the immediately
+      # preceding EMF+ record (across comments) is linked; anything else is
+      # reported. Returns [links, errors].
+      def effect_links(frames)
+        links = []
+        errors = []
+        frames.each_with_index do |frame, index|
+          next unless effect_draw?(frame)
+
+          effect = frames[index - 1] if index.positive? && frames[index - 1].type == SERIALIZABLE_OBJECT
+          effect ? links << EffectLink.new(draw: frame, effect: effect) : errors << effect_error(frames, index)
+        end
+        [links.freeze, errors.freeze]
+      end
+
+      def emr_range_after(frames, index, record_count)
+        frame = frames[index]
+        following = frames[index + 1]
+        first = frame.comment_index + 1
+        return first...first if following&.comment_index == frame.comment_index
+
+        first...(following ? following.comment_index : record_count)
+      end
+
+      def effect_draw?(frame)
+        frame.type == DRAW_IMAGE_POINTS && frame.flags.anybits?(EFFECT_FLAG)
+      end
+
+      def effect_error(frames, index)
+        frame = frames[index]
+        earlier = frames[0...index].any? { |f| f.type == SERIALIZABLE_OBJECT }
+        reason = earlier ? :non_adjacent_effect : :missing_effect
+        message = if earlier
+                    "E-flag DrawImagePoints is not immediately preceded by a SerializableObject"
+                  else
+                    "E-flag DrawImagePoints has no SerializableObject"
+                  end
+        LinkError.new(reason: reason, comment_index: frame.comment_index, offset: frame.offset, message: message)
+      end
+
+      private_class_method :emr_range_after, :effect_draw?, :effect_error
+    end
+  end
+end