emfsvg 0.1.1 → 0.1.2

data/lib/emfsvg/svg/parser.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+require "nokogiri"
+
+module Emfsvg
+  module Svg
+    # Parses an SVG document string into a Svg::Document value object.
+    # Nokogiri is the only XML/HTML parser used in this gem.
+    #
+    # Width/height are coerced to floats (CSS units other than px are
+    # out of scope for v1; a numeric value is treated as user units).
+    # viewBox is parsed into a 4-tuple [min_x, min_y, width, height].
+    module Parser
+      module_function
+
+      def call(string)
+        doc = Nokogiri::XML(string, &:noblanks)
+        root = doc.root
+        raise ParseError, "not an SVG document: missing root element" unless root
+
+        Document.new(
+          width: parse_dimension(root["width"]),
+          height: parse_dimension(root["height"]),
+          view_box: parse_view_box(root["viewBox"]),
+          root_element: Element.from_node(root)
+        )
+      end
+
+      def parse_dimension(value)
+        return 0.0 if value.nil? || value.empty?
+
+        match = value.match(/\A(-?\d+(?:\.\d+)?)/)
+        match ? match[1].to_f : 0.0
+      end
+
+      def parse_view_box(value)
+        return nil if value.nil? || value.empty?
+
+        parts = value.split(/[\s,]+/).map(&:to_f)
+        parts.length == 4 ? parts : nil
+      end
+    end
+  end
+end

data/lib/emfsvg/svg/path_data/command.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Emfsvg
+  module Svg
+    module PathData
+      # One parsed SVG path command (e.g. "M 1 2" or "L 3 4").
+      # `letter` preserves case (absolute uppercase vs relative lowercase).
+      Command = Struct.new(:letter, :args, keyword_init: true) do
+        def absolute?
+          letter == letter.upcase
+        end
+      end
+    end
+  end
+end

data/lib/emfsvg/svg/path_data.rb

@@ -0,0 +1,135 @@
+# frozen_string_literal: true
+
+module Emfsvg
+  module Svg
+    # Namespace for the SVG path-data parser. Pure parser, no EMF
+    # concerns. The translation layer (Phase 03 path handler) consumes
+    # the resulting Command list.
+    module PathData
+      autoload :Command, "emfsvg/svg/path_data/command"
+
+      # Arg count per command letter. M repeats as L (handled in parser).
+      ARG_COUNTS = {
+        "M" => 2, "L" => 2, "H" => 1, "V" => 1, "C" => 6, "S" => 4,
+        "Q" => 4, "T" => 2, "A" => 7, "Z" => 0
+      }.freeze
+
+      # Stateful parser walks the string once, emitting Commands as
+      # enough args accumulate for the current letter. Implicit repeats:
+      # subsequent arg groups after M/m are treated as L/l.
+      module Parser
+        module_function
+
+        def parse(string)
+          return [] if string.nil? || string.empty?
+
+          commands = []
+          scanner = Scanner.new(string)
+          current_letter = nil
+          args = []
+
+          while (token = scanner.next_token)
+            case token
+            when Symbol # command letter
+              flush_command(commands, current_letter, args) if current_letter && args.any?
+              current_letter = token.to_s
+              args = []
+              # Zero-arg commands (Z/z) emit immediately.
+              if ARG_COUNTS.fetch(current_letter.upcase, 1).zero?
+                emit_command(commands, current_letter, [])
+                current_letter = nil
+              end
+            when Numeric
+              raise FormatError, "path data begins with a number: #{string.inspect}" if current_letter.nil?
+
+              args << token
+              if args.size == ARG_COUNTS.fetch(current_letter.upcase)
+                emit_command(commands, current_letter, args)
+                args = []
+                current_letter = implicit_repeat_letter(current_letter)
+              end
+            end
+          end
+
+          flush_command(commands, current_letter, args) if current_letter && args.any?
+          commands
+        end
+
+        def emit_command(commands, letter, args)
+          raise FormatError, "unknown path command: #{letter}" unless ARG_COUNTS.key?(letter.upcase)
+
+          commands << Command.new(letter: letter, args: args.dup)
+        end
+
+        def flush_command(_commands, letter, args)
+          return unless letter
+          return if args.empty?
+
+          expected = ARG_COUNTS.fetch(letter.upcase, 0)
+          return if args.size == expected
+
+          raise FormatError, "path command #{letter} expected #{expected} args, got #{args.size}"
+        end
+
+        # M/m repeats as L/l per SVG spec; all other commands repeat as
+        # themselves.
+        def implicit_repeat_letter(letter)
+          case letter
+          when "M" then "L"
+          when "m" then "l"
+          else letter
+          end
+        end
+      end
+
+      # Character-stream tokenizer for path data. Emits command letters
+      # as Symbols (e.g. :M, :z) and numbers as Floats.
+      class Scanner
+        NUMBER_RE = /[+-]?(?:\d+\.?\d*|\.\d+)(?:[eE][+-]?\d+)?/
+
+        def initialize(string)
+          @string = string
+          @pos = 0
+        end
+
+        def next_token
+          skip_separators
+          return nil if @pos >= @string.length
+
+          char = @string[@pos]
+          if command_letter?(char)
+            @pos += 1
+            char.to_sym
+          else
+            read_number
+          end
+        end
+
+        private
+
+        def skip_separators
+          @pos += 1 while @pos < @string.length && separator?(@string[@pos])
+        end
+
+        def separator?(char)
+          case char
+          when " ", "\t", "\n", "\r", "," then true
+          else false
+          end
+        end
+
+        def command_letter?(char)
+          ("A".."Z").cover?(char) || ("a".."z").cover?(char)
+        end
+
+        def read_number
+          match = @string.match(NUMBER_RE, @pos)
+          raise FormatError, "expected number at position #{@pos} in path data" unless match
+
+          @pos = match.end(0)
+          match.to_s.to_f
+        end
+      end
+    end
+  end
+end

data/lib/emfsvg/svg/stroke.rb

@@ -0,0 +1,107 @@
+# frozen_string_literal: true
+
+module Emfsvg
+  module Svg
+    # Parsed SVG stroke style: color, width, dash pattern, line cap,
+    # line join. Maps directly to the EMF LOGPEN / EXTLOGPEN32 fields.
+    #
+    # Pen style bits (per MS-WMF 2.1.1.8 / emr_visitor.rb mirror):
+    #
+    #   PS_SOLID=0, PS_DASH=1, PS_DOT=2, PS_DASHDOT=3, PS_DASHDOTDOT=4,
+    #   PS_NULL=5
+    #
+    #   bits 8-11: PS_ENDCAP_ROUND=0x0000, _SQUARE=0x0100, _FLAT=0x0200
+    #   bits 12-15: PS_JOIN_ROUND=0x0000, _BEVEL=0x1000, _MITER=0x2000
+    #
+    # emfsvg's EMF→SVG renderer emits `stroke-width="1px"` (with the px
+    # suffix) AND no linecap/linejoin attrs as the fallback for a NULL
+    # pen with a solid brush. When the SVG→EMF side sees that exact
+    # form, it round-trips back to a NULL pen to preserve the rendering.
+    class Stroke
+      END_CAP_BITS = { "butt" => 0x0200, "round" => 0x0000, "square" => 0x0100 }.freeze
+      LINE_JOIN_BITS = { "miter" => 0x2000, "round" => 0x0000, "bevel" => 0x1000 }.freeze
+      NULL_PEN_WIDTH_SENTINEL = "1px"
+
+      attr_reader :paint, :width, :dash_array, :line_cap, :line_join, :raw_width,
+                  :line_cap_explicit, :line_join_explicit
+
+      def initialize(paint:, width: 1.0, dash_array: nil, line_cap: "round",
+                     line_join: "round", raw_width: nil,
+                     line_cap_explicit: false, line_join_explicit: false)
+        @paint = paint
+        @width = width.to_f
+        @dash_array = dash_array
+        @line_cap = line_cap
+        @line_join = line_join
+        @raw_width = raw_width
+        @line_cap_explicit = line_cap_explicit
+        @line_join_explicit = line_join_explicit
+      end
+
+      def null_pen_sentinel?
+        raw_width == NULL_PEN_WIDTH_SENTINEL &&
+          !line_cap_explicit &&
+          !line_join_explicit
+      end
+
+      PS_GEOMETRIC = 0x00010000
+
+      # Pen style bitmask (full 32 bits). Includes:
+      #   * dash style (bits 0-7)
+      #   * end-cap (bits 8-11)
+      #   * line-join (bits 12-15)
+      #   * pen type GEOMETRIC (bit 16) — set when width > 1, so
+      #     emfsvg's EMF→SVG renderer uses the actual pen.width
+      #     instead of hardcoding 1.
+      def pen_style
+        base = if paint.null? || null_pen_sentinel?
+                 5 # PS_NULL
+               else
+                 dash_style
+               end
+        type_bit = width > 1.0 && !paint.null? ? PS_GEOMETRIC : 0
+        base | type_bit | END_CAP_BITS.fetch(line_cap, 0x0000) | LINE_JOIN_BITS.fetch(line_join, 0x0000)
+      end
+
+      def self.parse(stroke:, width:, dash_array:, line_cap:, line_join:)
+        new(
+          paint: Paint.from_stroke(stroke),
+          width: parse_width(width),
+          dash_array: parse_dash_array(dash_array),
+          line_cap: line_cap || "round",
+          line_join: line_join || "round",
+          raw_width: width,
+          line_cap_explicit: !line_cap.nil?,
+          line_join_explicit: !line_join.nil?
+        )
+      end
+
+      def self.parse_width(value)
+        return 1.0 if value.nil? || value.strip.empty?
+
+        match = value.match(/\A(-?\d+(?:\.\d+)?)/)
+        match ? match[1].to_f : 1.0
+      end
+
+      # SVG dasharray is a comma/space separated list of lengths; "none"
+      # means solid. We map the first length to a discrete dash style:
+      # a single length matching roughly the width → PS_DOT, longer →
+      # PS_DASH. Anything more complex is approximated as PS_DASH for v1.
+      def dash_style
+        return 0 if dash_array.nil? || dash_array.empty?
+
+        first = dash_array.first
+        return 0 if first.zero?
+
+        first < (width * 2) ? 2 : 1 # PS_DOT=2, PS_DASH=1
+      end
+
+      def self.parse_dash_array(value)
+        return nil if value.nil? || value.strip == "none" || value.strip.empty?
+
+        parts = value.split(/[\s,]+/).map(&:to_f)
+        parts.empty? ? nil : parts
+      end
+    end
+  end
+end

data/lib/emfsvg/svg/transform_parser.rb

@@ -0,0 +1,123 @@
+# frozen_string_literal: true
+
+module Emfsvg
+  module Svg
+    # Parse SVG `transform="..."` attribute syntax into a single
+    # `Emf::Model::Geometry::Matrix`. Handles translate(), scale(),
+    # rotate(), matrix(), skewX(), skewY().
+    #
+    # Convention: the emf gem's Matrix uses EMF's row-vector layout
+    # (v_new = v * M) — same as emfsvg's existing emr_visitor multiply.
+    # SVG `transform="A B"` means "apply A first, then B to the result"
+    # in row-vector terms, which equals the matrix product A * B.
+    module TransformParser
+      module_function
+
+      TRANSFORM_FN_RE = /([a-zA-Z]+)\s*\(([^)]*)\)/
+
+      def parse(string)
+        return Emf::Model::Geometry::Matrix.identity if string.nil? || string.strip.empty?
+
+        # Row-vector convention: v_new = v * M. SVG `transform="A B"`
+        # applies B first then A to local coords, which in row-vector
+        # equals the product B * A. Scanning left-to-right we compose
+        # on the LEFT so each new function pre-multiplies the accumulator.
+        string.scan(TRANSFORM_FN_RE).inject(Emf::Model::Geometry::Matrix.identity) do |composed, (name, args_str)|
+          args = args_str.split(/[\s,]+/).map(&:to_f)
+          fn_matrix = build_function(name.downcase, args)
+          multiply(fn_matrix, composed)
+        end
+      end
+
+      def build_function(name, args)
+        case name
+        when "matrix" then from_matrix_args(args)
+        when "translate" then translate_matrix(*args)
+        when "scale" then scale_matrix(*args)
+        when "rotate" then rotate_matrix(*args)
+        when "skewx" then skewx_matrix(args.first)
+        when "skewy" then skewy_matrix(args.first)
+        else
+          raise FormatError, "unknown SVG transform function: #{name}"
+        end
+      end
+
+      def from_matrix_args(args)
+        raise FormatError, "matrix() requires 6 args" if args.size != 6
+
+        Emf::Model::Geometry::Matrix.new(
+          m11: args[0], m12: args[1], m21: args[2], m22: args[3],
+          dx: args[4], dy: args[5]
+        )
+      end
+
+      def translate_matrix(*args)
+        tx = args.fetch(0, 0.0)
+        ty = args.fetch(1, 0.0)
+        Emf::Model::Geometry::Matrix.new(
+          m11: 1.0, m12: 0.0, m21: 0.0, m22: 1.0,
+          dx: tx, dy: ty
+        )
+      end
+
+      def scale_matrix(*args)
+        sx = args.fetch(0, 1.0)
+        sy = args.fetch(1, sx)
+        Emf::Model::Geometry::Matrix.new(
+          m11: sx, m12: 0.0, m21: 0.0, m22: sy,
+          dx: 0.0, dy: 0.0
+        )
+      end
+
+      # SVG rotate(angle) is visually clockwise (Y grows downward).
+      # With the emf gem's row-vector matrix layout, the equivalent
+      # transform applied around (cx, cy) is: T(-cx,-cy) * R * T(cx,cy).
+      # (The SVG spec text writes it as T(cx,cy) * R * T(-cx,-cy), but
+      # that's column-vector notation — row-vector reverses the order.)
+      def rotate_matrix(*args)
+        deg = args.fetch(0, 0.0)
+        cx = args.fetch(1, 0.0)
+        cy = args.fetch(2, 0.0)
+        rad = deg * Math::PI / 180.0
+        cos = Math.cos(rad)
+        sin = Math.sin(rad)
+        rot = Emf::Model::Geometry::Matrix.new(
+          m11: cos, m12: sin, m21: -sin, m22: cos,
+          dx: 0.0, dy: 0.0
+        )
+        return rot if cx.zero? && cy.zero?
+
+        multiply(multiply(translate_matrix(-cx, -cy), rot), translate_matrix(cx, cy))
+      end
+
+      def skewx_matrix(deg)
+        rad = deg * Math::PI / 180.0
+        Emf::Model::Geometry::Matrix.new(
+          m11: 1.0, m12: 0.0, m21: Math.tan(rad), m22: 1.0,
+          dx: 0.0, dy: 0.0
+        )
+      end
+
+      def skewy_matrix(deg)
+        rad = deg * Math::PI / 180.0
+        Emf::Model::Geometry::Matrix.new(
+          m11: 1.0, m12: Math.tan(rad), m21: 0.0, m22: 1.0,
+          dx: 0.0, dy: 0.0
+        )
+      end
+
+      # Row-vector matrix multiply: v * (a * b) = (v * a) * b. Matches
+      # emfsvg's emr_visitor#multiply_matrix formula.
+      def multiply(a, b)
+        Emf::Model::Geometry::Matrix.new(
+          m11: (a.m11 * b.m11) + (a.m12 * b.m21),
+          m12: (a.m11 * b.m12) + (a.m12 * b.m22),
+          m21: (a.m21 * b.m11) + (a.m22 * b.m21),
+          m22: (a.m21 * b.m12) + (a.m22 * b.m22),
+          dx: (a.dx * b.m11) + (a.dy * b.m21) + b.dx,
+          dy: (a.dx * b.m12) + (a.dy * b.m22) + b.dy
+        )
+      end
+    end
+  end
+end

data/lib/emfsvg/svg.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module Emfsvg
+  # Pure SVG domain model. No EMF knowledge lives here.
+  #
+  # Svg::Parser consumes a Nokogiri-parsed SVG document and produces
+  # Svg::Document / Svg::Element value objects. Translation layer
+  # (Emfsvg::Translation) consumes these.
+  module Svg
+    autoload :Document, "emfsvg/svg/document"
+    autoload :Element, "emfsvg/svg/element"
+    autoload :OpenElement, "emfsvg/svg/element"
+    autoload :Parser, "emfsvg/svg/parser"
+    autoload :AttributeParser, "emfsvg/svg/attribute_parser"
+    autoload :Color, "emfsvg/svg/color"
+    autoload :Paint, "emfsvg/svg/paint"
+    autoload :Stroke, "emfsvg/svg/stroke"
+    autoload :PathData, "emfsvg/svg/path_data"
+    autoload :TransformParser, "emfsvg/svg/transform_parser"
+    autoload :ClipPathRegistry, "emfsvg/svg/clip_path_registry"
+    autoload :Elements, "emfsvg/svg/elements"
+  end
+end
+
+require "emfsvg/svg/elements"

data/lib/emfsvg/translation/context.rb

@@ -0,0 +1,99 @@
+# frozen_string_literal: true
+
+require "emf"
+
+module Emfsvg
+  module Translation
+    # Mutable translation state carried through the element tree walk.
+    #
+    # Holds the GDI device context (pen/brush/font/transform), the
+    # 1-indexed object table, the SaveDC/RestoreDC stack, the
+    # coordinate scaler, and the output record list. All handlers
+    # receive a Context instance and operate on it functionally.
+    #
+    # Context also carries a reference to the HandlerRegistry so that
+    # GroupHandler (and other container handlers) can recurse into
+    # their children uniformly.
+    class Context
+      attr_reader :device_context, :object_table, :transform_stack, :emitter,
+                  :handler_registry, :clip_path_registry, :scaler
+
+      def initialize(handler_registry: EmfRenderer::DEFAULT_REGISTRY,
+                     clip_path_registry: nil,
+                     scaler: Scaler::Identity.new)
+        @device_context = DeviceContext.new
+        @object_table = ObjectTable.new
+        @transform_stack = TransformStack.new
+        @emitter = RecordEmitter.new
+        @handler_registry = handler_registry
+        @clip_path_registry = clip_path_registry
+        @scaler = scaler
+        @next_handle = 1
+      end
+
+      # Allocate the next 1-indexed GDI object handle. Always increments
+      # — no reuse in v1 (see TODO.roadmap/09-coalescing-optimization.adoc).
+      def allocate_handle
+        handle = @next_handle
+        @next_handle += 1
+        handle
+      end
+
+      def emit(wire_class, **attrs)
+        @emitter.emit(wire_class, **attrs)
+      end
+
+      def records
+        @emitter.records
+      end
+
+      # Dispatch an element through the registry. Container handlers
+      # (e.g. GroupHandler) call this to recurse into their children.
+      def dispatch(element)
+        handler = @handler_registry.handler_for(element)
+        handler&.call(element, self)
+      end
+
+      # ---- Coordinate-scaled wire helpers (DRY: handlers route all
+      # coords through these so the scaler affects everything) ----
+
+      def point_l(x, y)
+        Emf::Binary::Types::PointL.new(x: scale_int(x), y: scale_int(y))
+      end
+
+      def rect_l(left, top, right, bottom)
+        Emf::Binary::Types::RectL.new(
+          left: scale_int(left), top: scale_int(top),
+          right: scale_int(right), bottom: scale_int(bottom)
+        )
+      end
+
+      def size_l(cx, cy)
+        Emf::Binary::Types::SizeL.new(cx: scale_int(cx), cy: scale_int(cy))
+      end
+
+      # Convert a Matrix to its wire form, scaling the translation
+      # (dx/dy) by the scaler's factor. The 2x2 rotation/scale
+      # coefficients are NOT scaled — they're dimensionless ratios
+      # and survive any isometric map-mode change intact.
+      def xform_wire_from(matrix)
+        factor = @scaler.factor
+        return matrix.to_wire if factor == 1
+
+        scaled = Emf::Model::Geometry::Matrix.new(
+          m11: matrix.m11, m12: matrix.m12,
+          m21: matrix.m21, m22: matrix.m22,
+          dx: matrix.dx * factor,
+          dy: matrix.dy * factor
+        )
+        scaled.to_wire
+      end
+
+      private
+
+      def scale_int(value)
+        @scaler.to_int(value)
+      end
+    end
+  end
+end

data/lib/emfsvg/translation/decimal_detector.rb

@@ -0,0 +1,112 @@
+# frozen_string_literal: true
+
+module Emfsvg
+  module Translation
+    # Walks an Svg::Document tree to decide whether any coordinate
+    # attribute has a non-integer value. If yes, the renderer installs
+    # `Scaler::Fixed` and emits MapMode scaling records so the
+    # decimals survive the int32 truncation in EMF.
+    #
+    # Also detects overflow: if any decimal coord is so large that
+    # scaling would overflow int32, the renderer falls back to
+    # Identity (accepting the truncation for that fixture).
+    module DecimalDetector
+      module_function
+
+      def needs_scaling?(document)
+        any_decimal?(document.root_element)
+      end
+
+      def safe_for_fixed_scale?(document, scaler)
+        !any_unsafe?(document.root_element, scaler)
+      end
+
+      # ---- private ----
+
+      def any_decimal?(element)
+        return false unless element
+
+        element_attrs = decimal_attrs_for(element)
+        return true if element_attrs.any? { |attr| has_decimal?(element.send(attr)) }
+
+        path = path_commands(element)
+        return true if path && path.any? { |cmd| cmd.args.any? { |a| a.is_a?(Float) && a != a.to_i } }
+
+        element.children.any? { |c| any_decimal?(c) }
+      end
+
+      def any_unsafe?(element, scaler)
+        return false unless element
+
+        element_attrs = decimal_attrs_for(element)
+        return true if element_attrs.any? { |attr| unsafe_value?(element.send(attr), scaler) }
+
+        path = path_commands(element)
+        return true if path && path.any? { |cmd| cmd.args.any? { |a| scaler.unsafe?(a) } }
+
+        element.children.any? { |c| any_unsafe?(c, scaler) }
+      end
+
+      # Coordinate-bearing attributes per element class. Returns [] for
+      # elements with no coords (Group, Defs, etc).
+      def decimal_attrs_for(element)
+        case element
+        when Svg::Elements::Rect then %i[x y width height rx ry]
+        when Svg::Elements::Ellipse then %i[cx cy rx ry]
+        when Svg::Elements::Circle then %i[cx cy r]
+        when Svg::Elements::Line then %i[x1 y1 x2 y2]
+        when Svg::Elements::Polyline, Svg::Elements::Polygon then [:points]
+        when Svg::Elements::Path then [:commands]
+        when Svg::Elements::Text then %i[x y font_size]
+        when Svg::Elements::Image then %i[x y width height]
+        else []
+        end
+      end
+
+      def path_commands(element)
+        return nil unless element.is_a?(Svg::Elements::Path)
+
+        element.commands
+      end
+
+      # `value` may be: Float, Integer, Array of [x,y] pairs, Array of
+      # PathData::Command, or nil.
+      def has_decimal?(value)
+        return false if value.nil?
+
+        case value
+        when Float then !value.finite? || (value != value.to_i)
+        when Integer then false
+        when Array
+          value.any? { |v| pair_or_command?(v) ? has_decimal?(v) : v.is_a?(Float) && v != v.to_i }
+        when String then value.match?(/\.\d/)
+        else false
+        end
+      end
+
+      def pair_or_command?(value)
+        value.is_a?(Array) || value.is_a?(Svg::PathData::Command)
+      end
+
+      def unsafe_value?(value, scaler)
+        return false if value.nil?
+
+        case value
+        when Float then scaler.unsafe?(value)
+        when Integer then false
+        when Array then value.any? { |v| unsafe_value?(v, scaler) }
+        when String then extract_floats(value).any? { |f| scaler.unsafe?(f) }
+        else false
+        end
+      end
+
+      def path_unsafe?(path_str, scaler)
+        extract_floats(path_str).any? { |f| scaler.unsafe?(f) }
+      end
+
+      def extract_floats(str)
+        str.to_s.scan(/-?\d+(?:\.\d+)?/).map(&:to_f)
+      end
+    end
+  end
+end