postsvg 0.1.0 → 0.3.0

data/lib/postsvg/svg/attribute_parser.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module Postsvg
+  module Svg
+    # Helpers for parsing presentation attributes into typed values.
+    # Used by Element.from_node factories.
+    module AttributeParser
+      module_function
+
+      # Parse a length attribute ("10", "10px", "10pt", "50%").
+      # Returns a Float. Percentage values resolve to nil — the caller
+      # must know the reference dimension.
+      def length(text)
+        return nil if text.nil? || text.empty?
+
+        match = text.strip.match(/\A(-?\d+(?:\.\d+)?)(px|pt|in|cm|mm|em|ex|%)?\z/)
+        return nil unless match
+
+        return nil if match[2] == "%"
+
+        value = match[1].to_f
+        case match[2]
+        when "pt" then value * (1.0 / 72.0) * 72.0 # PS uses points natively
+        when "in" then value * 72.0
+        when "cm" then value * (72.0 / 2.54)
+        when "mm" then value * (72.0 / 25.4)
+        else value
+        end
+      end
+
+      def number_list(text)
+        return [] if text.nil? || text.empty?
+
+        text.scan(/-?\d+(?:\.\d+)?(?:[eE][-+]?\d+)?/).map(&:to_f)
+      end
+
+      def number(text, default: nil)
+        return default if text.nil? || text.empty?
+
+        match = text.strip.match(/\A(-?\d+(?:\.\d+)?(?:[eE][-+]?\d+)?)\z/)
+        match ? match[1].to_f : default
+      end
+    end
+  end
+end

data/lib/postsvg/svg/clip_path_registry.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module Postsvg
+  module Svg
+    # Indexes <clipPath id="..."> definitions in a document so handlers
+    # can resolve url(#id) references without re-walking the tree.
+    class ClipPathRegistry
+      attr_reader :by_id
+
+      def initialize(by_id = {})
+        @by_id = by_id.dup.freeze
+        freeze
+      end
+
+      def self.empty
+        @empty ||= new({})
+      end
+
+      def lookup(id)
+        @by_id[id]
+      end
+
+      def key?(id)
+        @by_id.key?(id)
+      end
+
+      # Build a registry by scanning +root+ for <clipPath> children.
+      def self.from_node(root)
+        registry = {}
+        root.xpath(".//*[local-name()='clipPath']").each do |node|
+          id = node["id"]
+          next unless id
+
+          # Concatenate the d attributes of all child <path> elements
+          # in document order. Other shape children are converted to
+          # path data lazily; for now we only support <path>.
+          ds = node.xpath(".//*[local-name()='path']").map { |p| p["d"] }.compact
+          registry[id] = ds.join(" ") unless ds.empty?
+        end
+        new(registry)
+      end
+    end
+  end
+end

data/lib/postsvg/svg/document.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Postsvg
+  module Svg
+    # Root value object produced by Svg::Parser. Carries the SVG root
+    # element, the document's viewBox / width / height (parsed once),
+    # and the ClipPathRegistry assembled from <defs>.
+    class Document
+      attr_reader :root_element, :viewbox, :width, :height, :clip_paths
+
+      def initialize(root_element:, viewbox: nil, width: nil, height: nil,
+                     clip_paths: ClipPathRegistry.empty)
+        @root_element = root_element
+        @viewbox = viewbox
+        @width = width
+        @height = height
+        @clip_paths = clip_paths
+        freeze
+      end
+    end
+  end
+end

data/lib/postsvg/svg/element.rb

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+module Postsvg
+  module Svg
+    # Base value object for an SVG element. Subclasses (Svg::Elements::*)
+    # carry typed semantic fields; the base provides a uniform interface
+    # for the translation layer's dispatch.
+    #
+    # Element instances are immutable: built once from a Nokogiri node
+    # via the .from_node factory. The node is not retained.
+    #
+    # Every element exposes `children`, `transform`, `clip_path_id`,
+    # `fill`, `stroke_paint`, `stroke`, `stroke_paint_value`, all
+    # defaulting to nil / []. Subclasses override only the attributes
+    # that are actually present in the source element. This lets the
+    # Translation::Handlers::Shared helpers call any of these methods
+    # uniformly without resorting to `respond_to?` type checks.
+    class Element
+      ELEMENT_NAME = "abstract"
+
+      attr_reader :transform, :clip_path_id, :attributes,
+                  :children, :fill, :stroke_paint, :stroke
+
+      def initialize(transform: nil, clip_path_id: nil, attributes: {},
+                     children: [], fill: nil, stroke_paint: nil, stroke: nil)
+        @transform = transform
+        @clip_path_id = clip_path_id
+        @attributes = attributes.dup.freeze
+        @children = children.freeze
+        @fill = fill
+        @stroke_paint = stroke_paint
+        @stroke = stroke
+      end
+
+      # Default paint: black fill, no stroke. Handlers can override.
+      def default_fill
+        nil
+      end
+
+      def element_name
+        self.class::ELEMENT_NAME
+      end
+
+      # Registry: SVG element name -> Element subclass. OCP: register
+      # new subclasses via Element.register("rect", Elements::Rect)
+      # instead of editing a switch. Backed by a constant Hash so
+      # subclasses share a single registry regardless of +self+ at
+      # the call site.
+      REGISTRY = {}
+
+      class << self
+        def registry
+          Postsvg::Svg::Element::REGISTRY
+        end
+
+        def register(element_name, subclass)
+          registry[element_name] = subclass
+        end
+
+        def from_node(node)
+          subclass = registry[node.name]
+          return subclass.from_node(node) if subclass
+
+          OpenElement.new(name: node.name,
+                          children: node.element_children.map { |c| from_node(c) })
+        end
+      end
+    end
+
+    # Fallback for unknown SVG element types. Carries the element name
+    # so handlers can skip or warn; carries children so traversal
+    # still descends into known subtrees.
+    class OpenElement < Element
+      ELEMENT_NAME = "open"
+
+      attr_reader :name
+
+      def initialize(name:, **rest)
+        super(**rest)
+        @name = name
+      end
+    end
+  end
+end

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

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module Postsvg
+  module Svg
+    module Elements
+      class Circle < Element
+        ELEMENT_NAME = "circle"
+        register ELEMENT_NAME, self
+
+        attr_reader :cx, :cy, :r, :fill, :stroke_paint, :stroke
+
+        def initialize(cx:, cy:, r:, fill:, stroke_paint:, stroke:, **rest)
+          super(**rest)
+          @cx = cx
+          @cy = cy
+          @r = r
+          @fill = fill
+          @stroke_paint = stroke_paint
+          @stroke = stroke
+        end
+
+        def self.from_node(node)
+          new(cx: AttributeParser.number(node["cx"], default: 0),
+              cy: AttributeParser.number(node["cy"], default: 0),
+              r: AttributeParser.number(node["r"], default: 0),
+              fill: Paint.parse(node["fill"]),
+              stroke_paint: Paint.parse(node["stroke"]),
+              stroke: Stroke.parse(node),
+              transform: TransformList.parse(node["transform"]),
+              clip_path_id: Elements.parse_clip_path_id(node["clip-path"]),
+              attributes: Elements.node_attributes(node))
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module Postsvg
+  module Svg
+    module Elements
+      class ClipPath < Element
+        ELEMENT_NAME = "clipPath"
+        register ELEMENT_NAME, self
+
+        attr_reader :id, :children
+
+        def initialize(id:, children: [], **rest)
+          super(**rest)
+          @id = id
+          @children = children.freeze
+        end
+
+        def self.from_node(node)
+          new(id: node["id"],
+              children: node.element_children.map { |c| Element.from_node(c) },
+              attributes: Elements.node_attributes(node))
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Postsvg
+  module Svg
+    module Elements
+      class Defs < Element
+        ELEMENT_NAME = "defs"
+        register ELEMENT_NAME, self
+
+        attr_reader :children
+
+        def initialize(children: [], **rest)
+          super(**rest)
+          @children = children.freeze
+        end
+
+        def self.from_node(node)
+          new(children: node.element_children.map { |c| Element.from_node(c) },
+              attributes: Elements.node_attributes(node))
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module Postsvg
+  module Svg
+    module Elements
+      class Ellipse < Element
+        ELEMENT_NAME = "ellipse"
+        register ELEMENT_NAME, self
+
+        attr_reader :cx, :cy, :rx, :ry, :fill, :stroke_paint, :stroke
+
+        def initialize(cx:, cy:, rx:, ry:, fill:, stroke_paint:, stroke:, **rest)
+          super(**rest)
+          @cx = cx
+          @cy = cy
+          @rx = rx
+          @ry = ry
+          @fill = fill
+          @stroke_paint = stroke_paint
+          @stroke = stroke
+        end
+
+        def self.from_node(node)
+          new(cx: AttributeParser.number(node["cx"], default: 0),
+              cy: AttributeParser.number(node["cy"], default: 0),
+              rx: AttributeParser.number(node["rx"], default: 0),
+              ry: AttributeParser.number(node["ry"], default: 0),
+              fill: Paint.parse(node["fill"]),
+              stroke_paint: Paint.parse(node["stroke"]),
+              stroke: Stroke.parse(node),
+              transform: TransformList.parse(node["transform"]),
+              clip_path_id: Elements.parse_clip_path_id(node["clip-path"]),
+              attributes: Elements.node_attributes(node))
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module Postsvg
+  module Svg
+    module Elements
+      class Group < Element
+        ELEMENT_NAME = "g"
+        register ELEMENT_NAME, self
+
+        attr_reader :children
+
+        def initialize(children: [], **rest)
+          super(**rest)
+          @children = children.freeze
+        end
+
+        def self.from_node(node)
+          new(children: node.element_children.map { |c| Element.from_node(c) },
+              transform: TransformList.parse(node["transform"]),
+              clip_path_id: Elements.parse_clip_path_id(node["clip-path"]),
+              attributes: Elements.node_attributes(node))
+        end
+      end
+
+      def self.node_attributes(node)
+        attrs = {}
+        node.attribute_nodes.each { |a| attrs[a.name] = a.value }
+        attrs
+      end
+
+      def self.parse_clip_path_id(text)
+        m = text&.match(/url\(\s*["']?#([^)\s"']+)/)
+        m && m[1]
+      end
+    end
+  end
+end

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

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module Postsvg
+  module Svg
+    module Elements
+      class Image < Element
+        ELEMENT_NAME = "image"
+        register ELEMENT_NAME, self
+
+        attr_reader :x, :y, :width, :height, :href
+
+        def initialize(x:, y:, width:, height:, href:, **rest)
+          super(**rest)
+          @x = x
+          @y = y
+          @width = width
+          @height = height
+          @href = href
+        end
+
+        def self.from_node(node)
+          href = node["href"] || node["xlink:href"]
+          new(x: AttributeParser.number(node["x"], default: 0),
+              y: AttributeParser.number(node["y"], default: 0),
+              width: AttributeParser.number(node["width"], default: 0),
+              height: AttributeParser.number(node["height"], default: 0),
+              href: href,
+              transform: TransformList.parse(node["transform"]),
+              clip_path_id: Elements.parse_clip_path_id(node["clip-path"]),
+              attributes: Elements.node_attributes(node))
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module Postsvg
+  module Svg
+    module Elements
+      class Line < Element
+        ELEMENT_NAME = "line"
+        register ELEMENT_NAME, self
+
+        attr_reader :x1, :y1, :x2, :y2, :stroke_paint, :stroke
+
+        def initialize(x1:, y1:, x2:, y2:, stroke_paint:, stroke:, **rest)
+          super(**rest)
+          @x1 = x1
+          @y1 = y1
+          @x2 = x2
+          @y2 = y2
+          @stroke_paint = stroke_paint
+          @stroke = stroke
+        end
+
+        def self.from_node(node)
+          new(x1: AttributeParser.number(node["x1"], default: 0),
+              y1: AttributeParser.number(node["y1"], default: 0),
+              x2: AttributeParser.number(node["x2"], default: 0),
+              y2: AttributeParser.number(node["y2"], default: 0),
+              stroke_paint: Paint.parse(node["stroke"]),
+              stroke: Stroke.parse(node),
+              transform: TransformList.parse(node["transform"]),
+              clip_path_id: Elements.parse_clip_path_id(node["clip-path"]),
+              attributes: Elements.node_attributes(node))
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module Postsvg
+  module Svg
+    module Elements
+      class Path < Element
+        ELEMENT_NAME = "path"
+        register ELEMENT_NAME, self
+
+        attr_reader :commands, :fill, :stroke_paint, :stroke
+
+        def initialize(commands:, fill:, stroke_paint:, stroke:, **rest)
+          super(**rest)
+          @commands = commands.freeze
+          @fill = fill
+          @stroke_paint = stroke_paint
+          @stroke = stroke
+        end
+
+        def self.from_node(node)
+          new(commands: PathData.parse(node["d"]),
+              fill: Paint.parse(node["fill"]),
+              stroke_paint: Paint.parse(node["stroke"]),
+              stroke: Stroke.parse(node),
+              transform: TransformList.parse(node["transform"]),
+              clip_path_id: Elements.parse_clip_path_id(node["clip-path"]),
+              attributes: Elements.node_attributes(node))
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module Postsvg
+  module Svg
+    module Elements
+      class Polygon < Polyline
+        ELEMENT_NAME = "polygon"
+        register ELEMENT_NAME, self
+      end
+    end
+  end
+end

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

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module Postsvg
+  module Svg
+    module Elements
+      class Polyline < Element
+        ELEMENT_NAME = "polyline"
+        register ELEMENT_NAME, self
+
+        attr_reader :points, :fill, :stroke_paint, :stroke
+
+        def initialize(points:, fill:, stroke_paint:, stroke:, **rest)
+          super(**rest)
+          @points = points.freeze
+          @fill = fill
+          @stroke_paint = stroke_paint
+          @stroke = stroke
+        end
+
+        def self.from_node(node)
+          new(points: AttributeParser.number_list(node["points"]),
+              fill: Paint.parse(node["fill"]),
+              stroke_paint: Paint.parse(node["stroke"]),
+              stroke: Stroke.parse(node),
+              transform: TransformList.parse(node["transform"]),
+              clip_path_id: Elements.parse_clip_path_id(node["clip-path"]),
+              attributes: Elements.node_attributes(node))
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module Postsvg
+  module Svg
+    module Elements
+      class Rect < Element
+        ELEMENT_NAME = "rect"
+        register ELEMENT_NAME, self
+
+        attr_reader :x, :y, :width, :height, :rx, :ry,
+                    :fill, :stroke_paint, :stroke
+
+        def initialize(x:, y:, width:, height:, rx:, ry:, fill:,
+                       stroke_paint:, stroke:, **rest)
+          super(**rest)
+          @x = x
+          @y = y
+          @width = width
+          @height = height
+          @rx = rx
+          @ry = ry
+          @fill = fill
+          @stroke_paint = stroke_paint
+          @stroke = stroke
+        end
+
+        def self.from_node(node)
+          new(x: AttributeParser.number(node["x"], default: 0),
+              y: AttributeParser.number(node["y"], default: 0),
+              width: AttributeParser.number(node["width"], default: 0),
+              height: AttributeParser.number(node["height"], default: 0),
+              rx: AttributeParser.number(node["rx"]),
+              ry: AttributeParser.number(node["ry"]),
+              fill: Paint.parse(node["fill"]),
+              stroke_paint: Paint.parse(node["stroke"]),
+              stroke: Stroke.parse(node),
+              transform: TransformList.parse(node["transform"]),
+              clip_path_id: Elements.parse_clip_path_id(node["clip-path"]),
+              attributes: Elements.node_attributes(node))
+        end
+      end
+    end
+  end
+end

data/lib/postsvg/svg/elements/svg.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module Postsvg
+  module Svg
+    module Elements
+      class Svg < Element
+        ELEMENT_NAME = "svg"
+        register ELEMENT_NAME, self
+
+        attr_reader :viewbox, :width, :height, :children
+
+        def initialize(viewbox: nil, width: nil, height: nil, children: [], **rest)
+          super(**rest)
+          @viewbox = viewbox
+          @width = width
+          @height = height
+          @children = children.freeze
+        end
+
+        def self.from_node(node)
+          children = node.element_children.map { |c| Element.from_node(c) }
+          vb = node["viewBox"]&.split(/[\s,]+/)&.map(&:to_f)
+          new(viewbox: (vb if vb&.length == 4),
+              width: AttributeParser.length(node["width"]),
+              height: AttributeParser.length(node["height"]),
+              children: children,
+              transform: TransformList.parse(node["transform"]),
+              clip_path_id: parse_clip_path_id(node["clip-path"]))
+        end
+
+        def self.parse_clip_path_id(text)
+          m = text&.match(/url\(\s*["']?#([^)\s"']+)/)
+          m && m[1]
+        end
+        private_class_method :parse_clip_path_id
+      end
+    end
+  end
+end

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

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module Postsvg
+  module Svg
+    module Elements
+      class Text < Element
+        ELEMENT_NAME = "text"
+        register ELEMENT_NAME, self
+
+        attr_reader :x, :y, :content, :font_family, :font_size,
+                    :fill, :stroke_paint, :stroke
+
+        def initialize(x:, y:, content:, font_family:, font_size:,
+                       fill:, stroke_paint:, stroke:, **rest)
+          super(**rest)
+          @x = x
+          @y = y
+          @content = content
+          @font_family = font_family
+          @font_size = font_size
+          @fill = fill
+          @stroke_paint = stroke_paint
+          @stroke = stroke
+        end
+
+        def self.from_node(node)
+          new(x: AttributeParser.number(node["x"], default: 0),
+              y: AttributeParser.number(node["y"], default: 0),
+              content: node.text,
+              font_family: node["font-family"] || "Helvetica",
+              font_size: AttributeParser.number(node["font-size"], default: 12),
+              fill: Paint.parse(node["fill"]),
+              stroke_paint: Paint.parse(node["stroke"]),
+              stroke: Stroke.parse(node),
+              transform: TransformList.parse(node["transform"]),
+              clip_path_id: Elements.parse_clip_path_id(node["clip-path"]),
+              attributes: Elements.node_attributes(node))
+        end
+      end
+    end
+  end
+end

data/lib/postsvg/svg/elements.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module Postsvg
+  module Svg
+    # Element subclass catalogue. Each subclass is registered with its
+    # SVG tag name. The +load_all!+ class method forces each autoload
+    # to fire; this populates the Element.registry so Svg::Parser can
+    # dispatch by tag name.
+    module Elements
+      autoload :Svg, "postsvg/svg/elements/svg"
+      autoload :Group, "postsvg/svg/elements/group"
+      autoload :Path, "postsvg/svg/elements/path"
+      autoload :Rect, "postsvg/svg/elements/rect"
+      autoload :Circle, "postsvg/svg/elements/circle"
+      autoload :Ellipse, "postsvg/svg/elements/ellipse"
+      autoload :Line, "postsvg/svg/elements/line"
+      autoload :Polyline, "postsvg/svg/elements/polyline"
+      autoload :Polygon, "postsvg/svg/elements/polygon"
+      autoload :Text, "postsvg/svg/elements/text"
+      autoload :Image, "postsvg/svg/elements/image"
+      autoload :Defs, "postsvg/svg/elements/defs"
+      autoload :ClipPath, "postsvg/svg/elements/clip_path"
+
+      class << self
+        def load_all!
+          constants.each { |c| const_get(c) }
+        end
+      end
+    end
+  end
+end