emfsvg 0.1.3 → 0.1.4

data/lib/emfsvg/translation/local_origin.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module Emfsvg
+  module Translation
+    # A complete absolute line can use a temporary integer device origin when
+    # its fixed-scale coordinates overflow. Restrict this to independent draws:
+    # pending paths, relative commands and clips carry additional state.
+    module LocalOrigin
+      module_function
+
+      def for_path(element, scaler)
+        return unless scaler.scaled? && independent_line?(element)
+
+        points = element.commands.map(&:args)
+        return unless finite_points?(points)
+        return unless points.flatten.any? { |value| scaler.unsafe?(value) }
+
+        origin = points.transpose.map do |values|
+          values.any? { |value| scaler.unsafe?(value) } ? ((values.min + values.max) / 2.0).floor : 0
+        end
+        return unless origin.all? { |value| Scaler::Fixed::INT32_RANGE.cover?(value) }
+        return unless points.all? { |point| point.zip(origin).all? { |value, offset| !scaler.unsafe?(value - offset) } }
+
+        origin
+      end
+
+      def independent_line?(element)
+        element.is_a?(Svg::Elements::Path) && element.children.empty? &&
+          !element.clip_path && element.fill.null? && element.path_record_kind.nil? &&
+          [nil, :polyline].include?(element.line_record_kind) && element.commands.map(&:letter) == %w[M L]
+      end
+
+      def finite_points?(points)
+        points.all? do |point|
+          point.size == 2 && point.all? { |value| value.is_a?(Numeric) && value.finite? }
+        end
+      end
+    end
+  end
+end

data/lib/emfsvg/translation/record_emitter.rb

@@ -19,17 +19,20 @@ module Emfsvg
 
       attr_reader :records
 
-      def emit(wire_class, **attrs)
-        record = build(wire_class, **attrs)
+      def emit(wire_class, attrs)
+        record = build(wire_class, attrs)
         @records << record
         record
       end
 
       # Construct without appending. Useful for inline inspection in tests.
-      def build(wire_class, **attrs)
+      def build(wire_class, attrs)
+        adapter = Emf::Model::Emr::Records::WireAdapter
+        return adapter.build(wire_class, **attrs) if adapter.respond_to?(:build)
+
         wire = wire_class.new(**attrs)
-        wire.n_size = wire.to_binary_s.bytesize
-        Emf::Model::Emr::Records::WireAdapter.new(wire: wire)
+        wire.n_size = wire.num_bytes
+        adapter.new(wire: wire)
       end
     end
   end

data/lib/emfsvg/translation/scaler/fixed.rb

@@ -13,8 +13,11 @@ module Emfsvg
       # Larger factors risk int32 overflow on big coords (max safe
       # SVG coord ~ 214_000 with FACTOR=10_000).
       class Fixed
+        class Overflow < RangeError; end
+
+        INT32_RANGE = (-(2**31)..((2**31) - 1))
         FACTOR = 10_000
-        MAX_SAFE_INPUT = 214_748 # (2**31 - 1) / FACTOR, with margin
+        MAX_SAFE_INPUT = 214_748 # ((2**31) - 1) / FACTOR, with margin
 
         attr_reader :factor
 
@@ -23,6 +26,8 @@ module Emfsvg
         end
 
         def to_int(decimal)
+          raise Overflow, "coordinate exceeds scaled int32 range: #{decimal}" if unsafe?(decimal)
+
           (decimal.to_f * factor).round
         end
 
@@ -33,7 +38,8 @@ module Emfsvg
         # True if `value` would overflow int32 when scaled. The
         # renderer falls back to Identity when ANY coord is unsafe.
         def unsafe?(value)
-          value.to_f.abs > MAX_SAFE_INPUT
+          scaled = value.to_f * factor
+          !scaled.finite? || !INT32_RANGE.cover?(scaled.round)
         end
       end
     end

data/lib/emfsvg/translation.rb

@@ -12,5 +12,6 @@ module Emfsvg
     autoload :Handlers, "emfsvg/translation/handlers"
     autoload :Scaler, "emfsvg/translation/scaler"
     autoload :DecimalDetector, "emfsvg/translation/decimal_detector"
+    autoload :LocalOrigin, "emfsvg/translation/local_origin"
   end
 end

data/lib/emfsvg/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Emfsvg
-  VERSION = "0.1.3"
+  VERSION = "0.1.4"
 end