emfsvg 0.1.0 → 0.1.2

data/lib/emfsvg/svg/elements/circle.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module Emfsvg
+  module Svg
+    module Elements
+      # <circle cx cy r/> — equivalent to <ellipse> with rx=ry=r.
+      class Circle < Element
+        ELEMENT_NAME = "circle"
+        Element.register("circle", self)
+
+        attr_reader :cx, :cy, :r, :fill, :stroke, :clip_path
+
+        def initialize(cx:, cy:, r:, fill:, stroke:, clip_path: nil)
+          @cx = cx
+          @cy = cy
+          @r = r
+          @fill = fill
+          @stroke = stroke
+          @clip_path = clip_path
+        end
+
+        def self.from_node(node)
+          new(
+            cx: AttributeParser.float(node["cx"]),
+            cy: AttributeParser.float(node["cy"]),
+            r: AttributeParser.float(node["r"]),
+            **Stylable.parse_style(node)
+          )
+        end
+
+        def to_ellipse
+          Ellipse.new(cx: cx, cy: cy, rx: r, ry: r, fill: fill, stroke: stroke,
+                      clip_path: clip_path)
+        end
+      end
+    end
+  end
+end

data/lib/emfsvg/svg/elements/clip_path.rb

@@ -0,0 +1,128 @@
+# frozen_string_literal: true
+
+module Emfsvg
+  module Svg
+    module Elements
+      # <clipPath id="X">...</clipPath>: defines a clipping region.
+      # Contains one or more child shapes whose union forms the clip.
+      class ClipPath < Element
+        ELEMENT_NAME = "clipPath"
+        Element.register("clipPath", self)
+
+        attr_reader :id, :children
+
+        def initialize(id:, children:)
+          @id = id
+          @children = children
+        end
+
+        def self.from_node(node)
+          new(
+            id: node["id"],
+            children: node.element_children.map { |c| Element.from_node(c) }
+          )
+        end
+
+        # Bounds [left, top, right, bottom] of the clip region for
+        # IntersectClipRect emission. Handles three forms:
+        #
+        # 1. Single <rect> child — use rect bounds directly.
+        # 2. Single <path> child whose d-string traces a rectangle
+        #    (4 unique corners + close) — extract corner bounds.
+        # 3. Anything else — use the union bounding box of all child
+        #    geometry (lossy: curves flattened to bounds).
+        def clip_bounds
+          return nil if children.empty?
+
+          if children.size == 1
+            child = children.first
+            return rect_bounds(child) if child.is_a?(Elements::Rect)
+            return path_rect_bounds(child) if child.is_a?(Elements::Path)
+          end
+
+          bounding_box_of(children)
+        end
+
+        # Alias retained for backward compatibility with shared_gdi.rb.
+        def rectangular_bounds
+          clip_bounds
+        end
+
+        private
+
+        def rect_bounds(rect)
+          [rect.x, rect.y, rect.x + rect.width, rect.y + rect.height]
+        end
+
+        # emfsvg's IntersectClipRect renderer emits a 5-point closed
+        # path: M X1,Y1 L X2,Y1 L X2,Y2 L X1,Y2 L X1,Y1 Z Z. Detect
+        # that shape and recover (X1, Y1, X2, Y2).
+        def path_rect_bounds(path)
+          points = PathFlattenerForClip.new.flatten(path.commands)
+          return nil unless points && points.size >= 4
+
+          xs = points.map(&:first)
+          ys = points.map(&:last)
+          [xs.min, ys.min, xs.max, ys.max]
+        end
+
+        def bounding_box_of(elements)
+          xs, ys = [], []
+          elements.each do |e|
+            case e
+            when Elements::Rect
+              xs << e.x << e.x + e.width
+              ys << e.y << e.y + e.height
+            when Elements::Ellipse
+              xs << e.cx - e.rx << e.cx + e.rx
+              ys << e.cy - e.ry << e.cy + e.ry
+            when Elements::Path
+              points = PathFlattenerForClip.new.flatten(e.commands)
+              next unless points
+
+              points.each do |x, y|
+                xs << x
+                ys << y
+              end
+            end
+          end
+          return nil if xs.empty?
+
+          [xs.min, ys.min, xs.max, ys.max]
+        end
+
+        # Minimal path flattener for clip extraction. Only handles
+        # absolute M/L/H/V/Z — enough for emfsvg's rectangular clip
+        # output. Relative commands and curves fall through (returns
+        # nil → caller treats as non-rectangular).
+        class PathFlattenerForClip
+          def flatten(commands)
+            points = []
+            current = [0.0, 0.0]
+            commands.each do |cmd|
+              case cmd.letter
+              when "M"
+                current = cmd.args
+                points << current.dup
+              when "L"
+                current = cmd.args
+                points << current.dup
+              when "H"
+                current = [cmd.args.first, current.last]
+                points << current.dup
+              when "V"
+                current = [current.first, cmd.args.first]
+                points << current.dup
+              when "Z"
+                # close — ignored for bounds extraction
+              else
+                return nil
+              end
+            end
+            points
+          end
+        end
+      end
+    end
+  end
+end

data/lib/emfsvg/svg/elements/defs.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Emfsvg
+  module Svg
+    module Elements
+      # <defs>: container for reusable definitions (clipPath, etc.).
+      # Children are NOT rendered directly; they are referenced by id.
+      class Defs < Element
+        ELEMENT_NAME = "defs"
+        Element.register("defs", self)
+
+        attr_reader :children
+
+        def initialize(children:)
+          @children = children
+        end
+
+        def self.from_node(node)
+          new(children: node.element_children.map { |c| Element.from_node(c) })
+        end
+      end
+    end
+  end
+end

data/lib/emfsvg/svg/elements/ellipse.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module Emfsvg
+  module Svg
+    module Elements
+      # <ellipse cx cy rx ry/>
+      class Ellipse < Element
+        ELEMENT_NAME = "ellipse"
+        Element.register("ellipse", self)
+
+        attr_reader :cx, :cy, :rx, :ry, :fill, :stroke, :clip_path
+
+        def initialize(cx:, cy:, rx:, ry:, fill:, stroke:, clip_path: nil)
+          @cx = cx
+          @cy = cy
+          @rx = rx
+          @ry = ry
+          @fill = fill
+          @stroke = stroke
+          @clip_path = clip_path
+        end
+
+        def self.from_node(node)
+          new(
+            cx: AttributeParser.float(node["cx"]),
+            cy: AttributeParser.float(node["cy"]),
+            rx: AttributeParser.float(node["rx"]),
+            ry: AttributeParser.float(node["ry"]),
+            **Stylable.parse_style(node)
+          )
+        end
+      end
+    end
+  end
+end

data/lib/emfsvg/svg/elements/group.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+require "emf"
+
+module Emfsvg
+  module Svg
+    module Elements
+      # <g transform="...">...</g>: groups children with an optional
+      # coordinate transform applied to all descendants.
+      class Group < Element
+        ELEMENT_NAME = "g"
+        Element.register("g", self)
+
+        attr_reader :children, :transform_matrix
+
+        def initialize(children:, transform_matrix: Emf::Model::Geometry::Matrix.identity)
+          @children = children
+          @transform_matrix = transform_matrix
+        end
+
+        def transformed?
+          !transform_matrix.identity?
+        end
+
+        def self.from_node(node)
+          children = node.element_children.map { |c| Element.from_node(c) }
+          new(children: children,
+              transform_matrix: Svg::TransformParser.parse(node["transform"]))
+        end
+      end
+    end
+  end
+end

data/lib/emfsvg/svg/elements/image.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+module Emfsvg
+  module Svg
+    module Elements
+      # <image x y width height xlink:href="data:..."/>
+      # v1: data: URIs only (PNG, JPEG, base64-encoded). File/http URIs
+      # are out of scope.
+      class Image < Element
+        ELEMENT_NAME = "image"
+        Element.register("image", self)
+
+        attr_reader :x, :y, :width, :height, :href, :fill, :stroke, :clip_path
+
+        def initialize(x:, y:, width:, height:, href:, fill: nil, stroke: nil, clip_path: nil)
+          @x = x
+          @y = y
+          @width = width
+          @height = height
+          @href = href
+          @fill = fill
+          @stroke = stroke
+          @clip_path = clip_path
+        end
+
+        def self.from_node(node)
+          href = node["xlink:href"] || node["href"]
+          new(
+            x: AttributeParser.float(node["x"]),
+            y: AttributeParser.float(node["y"]),
+            width: AttributeParser.float(node["width"]),
+            height: AttributeParser.float(node["height"]),
+            href: href,
+            **Stylable.parse_style(node)
+          )
+        end
+
+        def data_uri?
+          href&.start_with?("data:")
+        end
+
+        def mime_type
+          return nil unless data_uri?
+
+          match = href.match(/\Adata:([^;,]+)/)
+          match ? match[1] : nil
+        end
+
+        def decoded_bytes
+          return nil unless data_uri?
+
+          match = href.match(/\Adata:[^;,]+(?:;[^,]*)*,(.*)\z/m)
+          return nil unless match
+
+          payload = match[1]
+          base64? ? Base64.decode64(payload) : payload
+        end
+
+        def base64?
+          href.include?(";base64,")
+        end
+      end
+    end
+  end
+end

data/lib/emfsvg/svg/elements/line.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module Emfsvg
+  module Svg
+    module Elements
+      # <line x1 y1 x2 y2/>
+      class Line < Element
+        ELEMENT_NAME = "line"
+        Element.register("line", self)
+
+        attr_reader :x1, :y1, :x2, :y2, :fill, :stroke, :clip_path
+
+        def initialize(x1:, y1:, x2:, y2:, fill:, stroke:, clip_path: nil)
+          @x1 = x1
+          @y1 = y1
+          @x2 = x2
+          @y2 = y2
+          @fill = fill
+          @stroke = stroke
+          @clip_path = clip_path
+        end
+
+        def self.from_node(node)
+          new(
+            x1: AttributeParser.float(node["x1"]),
+            y1: AttributeParser.float(node["y1"]),
+            x2: AttributeParser.float(node["x2"]),
+            y2: AttributeParser.float(node["y2"]),
+            **Stylable.parse_style(node)
+          )
+        end
+      end
+    end
+  end
+end

data/lib/emfsvg/svg/elements/path.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Emfsvg
+  module Svg
+    module Elements
+      # <path d="..."/>. Stores parsed PathData::Command list.
+      class Path < Element
+        ELEMENT_NAME = "path"
+        Element.register("path", self)
+
+        attr_reader :commands, :fill, :stroke, :clip_path
+
+        def initialize(commands:, fill:, stroke:, clip_path: nil)
+          @commands = commands
+          @fill = fill
+          @stroke = stroke
+          @clip_path = clip_path
+        end
+
+        def self.from_node(node)
+          new(
+            commands: Svg::PathData::Parser.parse(node["d"]),
+            **Stylable.parse_style(node)
+          )
+        end
+      end
+    end
+  end
+end

data/lib/emfsvg/svg/elements/polygon.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Emfsvg
+  module Svg
+    module Elements
+      # <polygon points="x1,y1 x2,y2 ..."/> — closed polyline.
+      class Polygon < Element
+        ELEMENT_NAME = "polygon"
+        Element.register("polygon", self)
+
+        attr_reader :points, :fill, :stroke, :clip_path
+
+        def initialize(points:, fill:, stroke:, clip_path: nil)
+          @points = points
+          @fill = fill
+          @stroke = stroke
+          @clip_path = clip_path
+        end
+
+        def self.from_node(node)
+          new(
+            points: AttributeParser.points(node["points"]),
+            **Stylable.parse_style(node)
+          )
+        end
+      end
+    end
+  end
+end

data/lib/emfsvg/svg/elements/polyline.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Emfsvg
+  module Svg
+    module Elements
+      # <polyline points="x1,y1 x2,y2 ..."/>
+      class Polyline < Element
+        ELEMENT_NAME = "polyline"
+        Element.register("polyline", self)
+
+        attr_reader :points, :fill, :stroke, :clip_path
+
+        def initialize(points:, fill:, stroke:, clip_path: nil)
+          @points = points
+          @fill = fill
+          @stroke = stroke
+          @clip_path = clip_path
+        end
+
+        def self.from_node(node)
+          new(
+            points: AttributeParser.points(node["points"]),
+            **Stylable.parse_style(node)
+          )
+        end
+      end
+    end
+  end
+end

data/lib/emfsvg/svg/elements/rect.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module Emfsvg
+  module Svg
+    module Elements
+      # <rect x y width height rx ry/>
+      # Produces EMR_RECTANGLE (no rx/ry) or EMR_ROUNDRECT (rx/ry present).
+      class Rect < Element
+        ELEMENT_NAME = "rect"
+        Element.register("rect", self)
+
+        attr_reader :x, :y, :width, :height, :rx, :ry, :fill, :stroke, :clip_path
+
+        def initialize(x:, y:, width:, height:, rx:, ry:, fill:, stroke:, clip_path: nil)
+          @x = x
+          @y = y
+          @width = width
+          @height = height
+          @rx = rx
+          @ry = ry
+          @fill = fill
+          @stroke = stroke
+          @clip_path = clip_path
+        end
+
+        def self.from_node(node)
+          new(
+            x: AttributeParser.float(node["x"]),
+            y: AttributeParser.float(node["y"]),
+            width: AttributeParser.float(node["width"]),
+            height: AttributeParser.float(node["height"]),
+            rx: AttributeParser.float(node["rx"]),
+            ry: AttributeParser.float(node["ry"]),
+            **Stylable.parse_style(node)
+          )
+        end
+
+        def rounded?
+          rx.positive? || ry.positive?
+        end
+      end
+    end
+  end
+end

data/lib/emfsvg/svg/elements/stylable.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module Emfsvg
+  module Svg
+    module Elements
+      # Common presentation attribute parsing shared by every shape.
+      # Module function — call as `Stylable.parse_style(node)` from
+      # an Element subclass's `.from_node` factory.
+      module Stylable
+        module_function
+
+        def parse_style(node)
+          {
+            fill: Svg::Paint.from_fill(node["fill"]),
+            stroke: Svg::Stroke.parse(
+              stroke: node["stroke"],
+              width: node["stroke-width"],
+              dash_array: node["stroke-dasharray"],
+              line_cap: node["stroke-linecap"],
+              line_join: node["stroke-linejoin"]
+            ),
+            clip_path: node["clip-path"]
+          }
+        end
+      end
+    end
+  end
+end

data/lib/emfsvg/svg/elements/text.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+require "emf"
+
+module Emfsvg
+  module Svg
+    module Elements
+      # <text x y font-family font-size font-weight fill>content</text>
+      # v1: single run, no <tspan>, no textPath. Content is read from the
+      # element's text node.
+      class Text < Element
+        ELEMENT_NAME = "text"
+        Element.register("text", self)
+
+        attr_reader :x, :y, :content, :font_family, :font_size, :font_weight,
+                    :font_style, :text_anchor, :fill, :stroke, :clip_path,
+                    :transform_matrix
+
+        def initialize(x:, y:, content:, font_family:, font_size:, font_weight:,
+                       font_style:, text_anchor:, fill:, stroke:, clip_path: nil,
+                       transform_matrix: Emf::Model::Geometry::Matrix.identity)
+          @x = x
+          @y = y
+          @content = content
+          @font_family = font_family
+          @font_size = font_size
+          @font_weight = font_weight
+          @font_style = font_style
+          @text_anchor = text_anchor
+          @fill = fill
+          @stroke = stroke
+          @clip_path = clip_path
+          @transform_matrix = transform_matrix
+        end
+
+        def transformed?
+          !transform_matrix.identity?
+        end
+
+        def self.from_node(node)
+          new(
+            x: AttributeParser.float(node["x"]),
+            y: AttributeParser.float(node["y"]),
+            content: node.text,
+            font_family: node["font-family"],
+            font_size: AttributeParser.float(node["font-size"], default: 12.0),
+            font_weight: parse_weight(node["font-weight"]),
+            font_style: node["font-style"],
+            text_anchor: node["text-anchor"] || "start",
+            transform_matrix: Svg::TransformParser.parse(node["transform"]),
+            **Stylable.parse_style(node)
+          )
+        end
+
+        def self.parse_weight(value)
+          return 400 if value.nil? || value == "normal"
+
+          value == "bold" ? 700 : value.to_i
+        end
+
+        def italic?
+          font_style == "italic"
+        end
+      end
+    end
+  end
+end

data/lib/emfsvg/svg/elements.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module Emfsvg
+  module Svg
+    # Subclasses of Svg::Element for the supported SVG shape vocabulary.
+    # Each subclass parses its typed attributes at construction time
+    # (no Nokogiri node is retained). Register in Svg::Element's
+    # registry so Svg::Element.from_node dispatches correctly.
+    module Elements
+      autoload :Stylable, "emfsvg/svg/elements/stylable"
+      autoload :Rect, "emfsvg/svg/elements/rect"
+      autoload :Circle, "emfsvg/svg/elements/circle"
+      autoload :Ellipse, "emfsvg/svg/elements/ellipse"
+      autoload :Line, "emfsvg/svg/elements/line"
+      autoload :Polyline, "emfsvg/svg/elements/polyline"
+      autoload :Polygon, "emfsvg/svg/elements/polygon"
+      autoload :Path, "emfsvg/svg/elements/path"
+      autoload :Group, "emfsvg/svg/elements/group"
+      autoload :Defs, "emfsvg/svg/elements/defs"
+      autoload :ClipPath, "emfsvg/svg/elements/clip_path"
+      autoload :Text, "emfsvg/svg/elements/text"
+      autoload :Image, "emfsvg/svg/elements/image"
+    end
+  end
+end
+
+# Eager-load element subclasses so they register with Svg::Element at
+# require time. The registry dispatch (Svg::Element.for) relies on all
+# subclasses having called Element.register() by the time parsing starts.
+require "emfsvg/svg/elements/stylable"
+require "emfsvg/svg/elements/rect"
+require "emfsvg/svg/elements/circle"
+require "emfsvg/svg/elements/ellipse"
+require "emfsvg/svg/elements/line"
+require "emfsvg/svg/elements/polyline"
+require "emfsvg/svg/elements/polygon"
+require "emfsvg/svg/elements/path"
+require "emfsvg/svg/elements/group"
+require "emfsvg/svg/elements/defs"
+require "emfsvg/svg/elements/clip_path"
+require "emfsvg/svg/elements/text"
+require "emfsvg/svg/elements/image"

data/lib/emfsvg/svg/paint.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module Emfsvg
+  module Svg
+    # Parsed SVG `stroke=` and `fill=` attribute values, mapped to a
+    # value object the translation layer can consume.
+    #
+    # `Paint` is a thin struct: it carries a `Color` (which may be the
+    # NULL sentinel for "none") and the original brush/pen style bits.
+    class Paint
+      SOLID = 0
+      NULL = 1
+
+      def initialize(color:, style: SOLID)
+        @style = style
+        @color = color
+      end
+
+      attr_reader :style, :color
+
+      def null?
+        style == NULL || color.null?
+      end
+
+      def self.from_fill(value)
+        color = Color.parse(value)
+        new(style: color.null? ? NULL : SOLID, color: color)
+      end
+
+      def self.from_stroke(value)
+        color = Color.parse(value)
+        new(style: color.null? ? NULL : SOLID, color: color)
+      end
+    end
+  end
+end