emf 0.1.2 → 0.2.0

data/lib/emf/emr/binary/font.rb

@@ -0,0 +1,159 @@
+# frozen_string_literal: true
+
+require "bindata"
+require "emf/emr/binary/lazy_utf16_array"
+
+module Emf
+  module Emr
+    module Binary
+      # Fixed UTF-16 fields retain code units, including units after a terminator.
+      class LogFont < BinData::Record
+        endian :little
+        int32 :height
+        int32 :width
+        int32 :escapement
+        int32 :orientation
+        int32 :weight
+        uint8 :italic
+        uint8 :underline
+        uint8 :strike_out
+        uint8 :char_set
+        uint8 :out_precision
+        uint8 :clip_precision
+        uint8 :quality
+        uint8 :pitch_and_family
+        lazy_utf16_array :facename, initial_length: 32
+      end
+
+      class Panose < BinData::Record
+        uint8 :family_type
+        uint8 :serif_style
+        uint8 :weight
+        uint8 :proportion
+        uint8 :contrast
+        uint8 :stroke_variation
+        uint8 :arm_style
+        uint8 :letterform
+        uint8 :midline
+        uint8 :x_height
+      end
+
+      class LogFontPanose < BinData::Record
+        endian :little
+        log_font :log_font
+        lazy_utf16_array :fullname, initial_length: 64
+        lazy_utf16_array :style, initial_length: 32
+        uint32 :version
+        uint32 :style_size
+        uint32 :match
+        uint32 :reserved
+        array :vendor_id, type: :uint8, initial_length: 4
+        uint32 :culture
+        panose :panose
+        array :padding, type: :uint8, initial_length: 2
+      end
+
+      class DesignVector < BinData::Record
+        endian :little
+        uint32 :signature
+        uint32 :num_axes
+        array :axis_values, type: :int32, initial_length: :num_axes
+      end
+
+      class LogFontExDv < BinData::Record
+        endian :little
+        log_font :log_font
+        lazy_utf16_array :fullname, initial_length: 64
+        lazy_utf16_array :style, initial_length: 32
+        lazy_utf16_array :script, initial_length: 32
+        design_vector :design_vector
+        rest :trailing
+      end
+
+      # The byte snapshot preserves the existing body API; font exposes the fields.
+      class FontBody < BinData::BasePrimitive
+        mandatory_parameter :byte_length
+
+        attr_accessor :font
+
+        def assign(value)
+          bytes = value.respond_to?(:snapshot) ? value.snapshot : value
+          @font = parse_font(bytes)
+          @assigned_size = bytes.bytesize
+          super(bytes)
+        end
+
+        def snapshot
+          @font ? value_to_binary_string(nil) : super
+        end
+
+        private
+
+        def read_and_return_value(io)
+          length = eval_parameter(:byte_length)
+          raise BinData::ValidityError, "font body is shorter than LOGFONT" if length < 92
+
+          bytes = io.readbytes(length)
+          @font = parse_font(bytes)
+          bytes
+        rescue IOError => e
+          raise BinData::ValidityError, e.message
+        end
+
+        def parse_font(bytes)
+          size = bytes.bytesize
+          raise BinData::ValidityError, "font body is shorter than LOGFONT" if size < 92
+
+          return LogFont.read(bytes) if size == 92
+          return LogFontPanose.read(bytes.ljust(320, "\0")) if size <= 320
+
+          validate_exdv(bytes)
+          LogFontExDv.read(bytes)
+        end
+
+        def validate_exdv(bytes)
+          raise BinData::ValidityError, "truncated LOGFONTEXDV" if bytes.bytesize < 356
+
+          signature, axes = bytes.byteslice(348, 8).unpack("V2")
+          raise BinData::ValidityError, "invalid design vector signature" unless signature == 0x08007664
+          raise BinData::ValidityError, "invalid design vector axis count" if axes > 16
+          raise BinData::ValidityError, "truncated design vector" if bytes.bytesize < 356 + (axes * 4)
+        end
+
+        def value_to_binary_string(value)
+          return value unless @font
+
+          bytes = @font.to_binary_s
+          if @font.is_a?(LogFontExDv)
+            validate_exdv(bytes)
+            unless @font.design_vector.axis_values.length == @font.design_vector.num_axes
+              raise BinData::ValidityError, "design vector axis count does not match values"
+            end
+          end
+          length = body_length
+          if @font.is_a?(LogFontPanose) && length.between?(93, 319)
+            raise BinData::ValidityError, "font edit exceeds partial Panose body" unless bytes.byteslice(length..).bytes.all?(&:zero?)
+
+            return bytes.byteslice(0, length)
+          end
+          raise BinData::ValidityError, "font body does not match record size" unless bytes.bytesize == length
+
+          bytes
+        end
+
+        # A record built in memory can be serialized before its nSize is set:
+        # emfsvg assigns a raw LOGFONTW body, then derives n_size from
+        # to_binary_s. Until nSize gives a size, the body keeps the size it
+        # was assigned; an explicit nSize is still validated.
+        def body_length
+          length = eval_parameter(:byte_length)
+          length.positive? || @assigned_size.nil? ? length : @assigned_size
+        end
+
+        def sensible_default
+          "".b
+        end
+      end
+    end
+  end
+end

data/lib/emf/emr/binary/lazy_utf16_array.rb

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+require "bindata"
+
+module Emf
+  module Emr
+    module Binary
+      # A fixed-length array of little-endian uint16 that keeps the bytes it read
+      # and builds the per-unit BinData objects only when an element is touched.
+      # A font record read and written back untouched never pays for them.
+      class LazyUtf16Array < BinData::Array
+        UNIT_BYTES = 2
+
+        default_parameter type: :uint16le
+
+        # BinData extends each instance with its initial_length plugin, which
+        # shadows class methods; extending last puts these in front of it.
+        def initialize_shared_instance
+          super
+          extend Lazy
+        end
+
+        def initialize_instance
+          super
+          @raw = nil
+        end
+
+        module Lazy
+          def do_read(io)
+            @elements = nil
+            @raw = io.readbytes(eval_parameter(:initial_length) * UNIT_BYTES)
+          end
+
+          def do_write(io)
+            @raw ? io.writebytes(@raw) : super
+          end
+
+          def do_num_bytes
+            @raw ? @raw.bytesize : super
+          end
+
+          def clear?
+            @raw ? @raw.count("\0") == @raw.bytesize : super
+          end
+
+          def length
+            @raw ? @raw.bytesize / UNIT_BYTES : super
+          end
+          alias size length
+
+          def assign(array)
+            return if equal?(array)
+
+            @raw = nil
+            super
+          end
+
+          private
+
+          def elements
+            materialize if @raw
+            super
+          end
+
+          # Build the full element list before publishing it, so a concurrent
+          # reader sees either the raw bytes or complete elements, never an
+          # empty array in between.
+          def materialize
+            raw = @raw
+            list = Array.new(raw.bytesize / UNIT_BYTES) { new_element }
+            io = BinData::IO::Read.new(raw)
+            list.each { |element| element.do_read(io) }
+            @elements = list
+            @raw = nil
+          end
+        end
+      end
+    end
+  end
+end
+
+BinData::RegisteredClasses.register("lazy_utf16_array", Emf::Emr::Binary::LazyUtf16Array)

data/lib/emf/emr/binary/pack_plan.rb

@@ -0,0 +1,144 @@
+# frozen_string_literal: true
+
+require_relative "pack_plan_check"
+require_relative "pack_plan_exact"
+require_relative "pack_plan_generate"
+require_relative "pack_plan_values"
+
+module Emf
+  module Emr
+    module Binary
+      # The bytes of `klass.new(**attrs)` with n_size set to the record's size,
+      # computed straight from the attributes, with no wire built. Compiled once
+      # per FastFill class from the instantiated template: the leaves in write
+      # order with their defaults, directives and ranges. It accepts only
+      # attributes whose BinData assignment is the identity: known fields, and
+      # in-range Integers (Floats float32 holds exactly, for float32 leaves) given as a
+      # symbol-keyed Hash or an instance of the field's own struct class, plus,
+      # for a point array record, a list of integer points. Everything else
+      # returns nil and the caller builds the wire.
+      #
+      # A plan is only used once it reproduces BinData's bytes on the leaf
+      # values it was compiled from (see `verified?`); otherwise `build`
+      # returns nil for the class.
+      class PackPlan
+        include PackPlanCheck
+        include PackPlanValues
+        include PackPlanExact
+        include PackPlanGenerate
+
+        LEAVES = {
+          "BinData::Uint32le" => ["V", 0, (2**32) - 1],
+          "BinData::Int32le" => ["l<", -(2**31), (2**31) - 1],
+          "BinData::Uint8" => ["C", 0, 255],
+          "Emf::Binary::Float32Le" => ["e", nil, nil]
+        }.freeze
+        private_constant :LEAVES
+
+        Leaf = Struct.new(:index)
+        Branch = Struct.new(:klass, :children)
+
+        # A verified plan for the filler's class, or nil.
+        def self.build(filler)
+          plan = new(filler)
+          plan if plan.verified?(filler)
+        rescue StandardError
+          nil
+        end
+
+        def initialize(filler)
+          template = filler.template
+          @leaves = []
+          @defaults = []
+          @tree = {}
+          @array = nil
+          @plain_leaves = true
+          template.field_names.each { |name| @tree[name] = node_of(template.public_send(name), name) }
+          @format = @leaves.map(&:first).join
+          @lows = @leaves.map { |leaf| leaf[1] }.freeze
+          @highs = @leaves.map { |leaf| leaf[2] }.freeze
+          @size = filler.size
+          @n_size = @tree.fetch(:n_size).index
+          @coord_bytes = 0
+          finish_points(filler)
+          generate_pack
+        end
+
+        # The record's bytes, or nil when any attribute needs BinData. n_size
+        # is the record's size unless `size` is false, which leaves it as
+        # given (or its default).
+        def pack(attrs, size: true)
+          pack_interpreted(attrs, size: size)
+        end
+
+        # The same result computed by walking the attributes; the generated
+        # `pack` (see PackPlanGenerate) falls back to it for anything but plain
+        # in-range attributes.
+        def pack_interpreted(attrs, size: true)
+          catch(:decline) do
+            values = @defaults.dup
+            coords = nil
+            attrs.each do |name, value|
+              node = @tree[name] or throw :decline
+              next if value.nil?
+
+              node.equal?(@array) ? coords = coords_of(value) : (store(values, node, value) or throw :decline)
+            end
+            finish(values, coords, size)
+          end
+        end
+
+        private
+
+        def node_of(field, name)
+          if field.is_a?(BinData::Array)
+            @array_name = name
+            return @array = Branch.new(field.class, nil)
+          end
+          return branch_of(field) if field.respond_to?(:field_names)
+
+          directive, low, high = LEAVES.fetch(field.class.name)
+          @plain_leaves &&= !field.has_parameter?(:value)
+          @leaves << [directive, low, high]
+          @defaults << field.value
+          Leaf.new(@leaves.size - 1)
+        end
+
+        def branch_of(struct)
+          children = struct.field_names.to_h { |name| [name, node_of(struct.public_send(name), name)] }
+          Branch.new(struct.class, children)
+        end
+
+        # The record's one array, which must come last, as `pack` appends it.
+        def finish_points(filler)
+          return unless @array
+
+          raise ArgumentError, "array is not the last field" unless @tree.keys.last == @array_name
+
+          @point_class, @coord_directive, @coord_low, @coord_high, @coord_bytes, count_name = filler.points_layout
+          @count_name = count_name
+          @count = @tree.fetch(count_name).index
+          @points_format = "#{@format}#{@coord_directive}*"
+          @plain_leaves &&= plain_point?
+        end
+
+        # A point is a struct of x and y, each a plain stored value, so a
+        # point's coordinates can be read from its field objects.
+        def plain_point?
+          point = @point_class.new
+          point.field_names == %i[x y] && %i[x y].none? { |name| point.public_send(name).has_parameter?(:value) }
+        end
+
+        # The wire read back from the bytes must be the wire BinData built,
+        # so the count must be the array's length (an absent array is empty).
+        def finish(values, coords, size)
+          throw :decline if @array && values[@count] != (coords ? coords.size / 2 : 0)
+
+          values[@n_size] = @size + (coords ? coords.size * @coord_bytes : 0) if size
+          values.concat(coords) if coords
+          values.pack(coords ? @points_format : @format)
+        end
+      end
+    end
+  end
+end

data/lib/emf/emr/binary/pack_plan_check.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+require "bindata"
+
+module Emf
+  module Emr
+    module Binary
+      # The self-check of a PackPlan: its bytes against BinData's.
+      module PackPlanCheck
+        # True when the plan's bytes equal BinData's for the defaults, for every
+        # leaf set alone, and for every leaf set at once.
+        def verified?(filler)
+          klass = filler.wire_class
+          cases = [{}] + each_leaf_attrs + [all_leaf_attrs, exact_attrs, exact_attrs(structs: true)]
+          cases << { @array_name => [{ x: 3, y: -4 }, { x: 5, y: 6 }] } if @array
+          return false unless pack({})
+
+          # A plan may decline a case (nil) but never differ from BinData.
+          cases.all? { |attrs| (bytes = pack(attrs)).nil? || bytes == reference(klass, attrs) }
+        end
+
+        private
+
+        # BinData's own constructor: Record.new would consult this plan.
+        BINDATA_NEW = BinData::Base.method(:new).unbind
+        private_constant :BINDATA_NEW
+
+        def reference(klass, attrs)
+          wire = BINDATA_NEW.bind_call(klass, **attrs)
+          wire.n_size = wire.num_bytes
+          wire.to_binary_s
+        end
+
+        def each_leaf_attrs
+          @tree.filter_map do |name, node|
+            next if node.equal?(@array)
+
+            { name => sample_value(node, 1) }
+          end
+        end
+
+        # Every field but n_size, the shape the generated `pack` takes first;
+        # `structs` gives nested structs and points as instances.
+        def exact_attrs(structs: false)
+          attrs = @tree.reject { |name, _| name == :n_size || name.equal?(@array_name) }
+                       .to_h { |name, node| [name, sample_value(node, 7)] }
+          attrs.each { |name, value| attrs[name] = @tree[name].klass.new(value) if structs && value.is_a?(Hash) }
+          return attrs unless @array
+
+          points = [{ x: 3, y: -4 }, { x: 5, y: 6 }]
+          points = points.map { |point| @point_class.new(point) } if structs
+          attrs.merge(@array_name => points, @count_name => 2)
+        end
+
+        def all_leaf_attrs
+          @tree.reject { |_, node| node.equal?(@array) }.to_h { |name, node| [name, sample_value(node, 7)] }
+        end
+
+        # Hash of distinct in-range values for a field.
+        def sample_value(node, seed)
+          return leaf_sample(node.index, seed) if node.is_a?(PackPlan::Leaf)
+
+          node.children.each_with_index.to_h { |(name, child), at| [name, sample_value(child, seed + at + 1)] }
+        end
+
+        def leaf_sample(index, seed)
+          _, low, high = @leaves[index]
+          return seed + 0.5 unless low # exact in float32
+
+          (seed * 3).clamp(low, high)
+        end
+      end
+    end
+  end
+end

data/lib/emf/emr/binary/pack_plan_exact.rb

@@ -0,0 +1,130 @@
+# frozen_string_literal: true
+
+module Emf
+  module Emr
+    module Binary
+      # The common call shape of `pack`, compiled to one boolean chain: every
+      # field but n_size given, nested structs and the point list as plain
+      # Hashes and Arrays of Hashes of in-range Integers (or exact Floats). A
+      # Hash with exactly as many keys as the struct has fields, every field
+      # read non-nil, has exactly the struct's keys, so no per-key bookkeeping
+      # is needed; the first value that is not plain makes the chain false and
+      # `pack` continues with the general path, which stays the authority on
+      # declines and results.
+      module PackPlanExact
+        private
+
+        # The source of the `if` that returns the exact shape's bytes, or ""
+        # when the record has no n_size to leave out.
+        def gen_exact
+          return "" unless @tree.key?(:n_size)
+
+          @exact_depth = 0
+          given = @tree.except(:n_size)
+          checks = given.map { |name, node| exact_check(name, node, "attrs") }
+          checks.unshift("attrs.size == #{given.size}", "attrs[:n_size].nil?")
+          <<~RUBY.gsub(/^(?=.)/, "  ")
+            if #{checks.join(" &&\n    ")}
+              v#{@n_size} = #{exact_size}
+              vals = [#{(0...@leaves.size).map { |index| "v#{index}" }.join(', ')}]
+            #{exact_return}end
+          RUBY
+        end
+
+        def exact_size
+          bytes = @array ? " + pts.size * #{@coord_bytes * 2}" : ""
+          "size ? #{@size}#{bytes} : #{@defaults[@n_size].inspect}"
+        end
+
+        def exact_return
+          return "  return vals.pack(#{@format.inspect})\n" unless @array
+
+          "  return vals.pack(#{@points_format.inspect}) if points_appended?(vals, pts)\n"
+        end
+
+        def exact_check(name, node, container)
+          read = "#{container}[#{name.inspect}]"
+          return exact_array(read) if node.equal?(@array)
+          return exact_leaf(node.index, read) if node.is_a?(PackPlan::Leaf)
+
+          sub = "h#{@exact_depth += 1}"
+          hash = ["#{sub}.instance_of?(Hash)", "#{sub}.size == #{node.children.size}"] +
+                 node.children.map { |child, n| exact_check(child, n, sub) }
+          return "((#{sub} = #{read}).instance_of?(Hash) &&\n    #{hash.drop(1).join(" &&\n    ")})" unless @plain_leaves
+
+          "((#{sub} = #{read}; #{hash.first}) &&\n    #{hash.drop(1).join(" &&\n    ")} ||\n    #{exact_struct(sub, node)})"
+        end
+
+        # A nested struct given as an instance of its own class: its leaves
+        # are read from the field objects' stored values, in field order.
+        # An unmade field, or a value not stored as a plain Integer or
+        # Float, makes the chain false.
+        def exact_struct(sub, node)
+          @gen_classes << node.klass
+          fields = "f#{sub}"
+          checks = node.children.each_with_index.map do |(_, child), at|
+            if child.is_a?(PackPlan::Leaf)
+              exact_leaf(child.index, "#{fields}[#{at}]&.instance_variable_get(:@value)")
+            else
+              exact_nested_struct(child, "#{fields}[#{at}]")
+            end
+          end
+          ["#{sub}.instance_of?(@gen_classes[#{@gen_classes.size - 1}])",
+           "(#{fields} = #{sub}.instance_variable_get(:@field_objs))", *checks].join(" &&\n    ")
+        end
+
+        def exact_nested_struct(node, read)
+          sub = "h#{@exact_depth += 1}"
+          "(#{sub} = #{read}) && #{exact_struct(sub, node)}"
+        end
+
+        def exact_array(read)
+          "(pts = #{read}).instance_of?(Array) &&\n    v#{@count} == pts.size"
+        end
+
+        def exact_leaf(index, read)
+          var = "v#{index}"
+          low = @lows[index]
+          return "float32_exact?(#{var} = #{read})" unless low
+
+          "(#{var} = #{read}).instance_of?(Integer) &&\n    #{var} >= #{low} && #{var} <= #{@highs[index]}"
+        end
+
+        # Appends the flat coordinates of `points`, which must each be a
+        # Hash of exactly x and y, or a plain point struct, in the point
+        # range; false for any other point, with `vals` then to be dropped.
+        def points_appended?(vals, points)
+          index = 0
+          count = points.size
+          while index < count
+            point = points[index]
+            appended = point.instance_of?(Hash) ? hash_point_appended?(vals, point) : struct_point_appended?(vals, point)
+            return false unless appended
+
+            index += 1
+          end
+          true
+        end
+
+        def hash_point_appended?(vals, point)
+          point.size == 2 && point_appended?(vals, point[:x], point[:y])
+        end
+
+        def struct_point_appended?(vals, point)
+          return false unless @plain_leaves && point.instance_of?(@point_class)
+
+          fields = point.instance_variable_get(:@field_objs) or return false
+          point_appended?(vals, fields[0]&.instance_variable_get(:@value), fields[1]&.instance_variable_get(:@value))
+        end
+
+        def point_appended?(vals, x, y)
+          return false unless x.instance_of?(Integer) && x >= @coord_low && x <= @coord_high &&
+                              y.instance_of?(Integer) && y >= @coord_low && y <= @coord_high
+
+          vals << x << y
+          true
+        end
+      end
+    end
+  end
+end