postsvg 0.1.0 → 0.2.1

data/lib/postsvg/svg/element.rb

@@ -0,0 +1,86 @@
+# 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 do |c|
+                            from_node(c)
+                          end)
+        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,39 @@
+# 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,40 @@
+# 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

data/lib/postsvg/svg/paint.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module Postsvg
+  module Svg
+    # Paint value object: resolves a CSS-style paint value to either
+    # a Color instance, a paint-server URL reference (gradient /
+    # pattern id), or :none.
+    Paint = Struct.new(:kind, :value, keyword_init: true) do
+      def self.parse(text)
+        return Paint.new(kind: :none) if text.nil? || text.strip == "none"
+
+        if text&.start_with?("url(")
+          id = text.match(/url\(\s*["']?#([^)\s"']+)/)
+          return Paint.new(kind: :reference, value: id && id[1])
+        end
+
+        color = begin
+          ::Postscript::Color.parse(text.to_s)
+        rescue ArgumentError
+          nil
+        end
+        if color
+          Paint.new(kind: :color, value: color)
+        else
+          Paint.new(kind: :none)
+        end
+      end
+
+      def none? = kind == :none
+      def reference? = kind == :reference
+      def color? = kind == :color
+    end
+  end
+end

data/lib/postsvg/svg/parser.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+require "nokogiri"
+
+module Postsvg
+  module Svg
+    # Parses an SVG document via Nokogiri and produces an Svg::Document.
+    # Pure: no I/O, no global state.
+    class Parser
+      def self.call(svg_string)
+        doc = Nokogiri::XML(svg_string, &:noblanks)
+        root = doc.root
+        raise TranslationError, "no root element in SVG" unless root
+
+        Elements.load_all! # populate Element.registry with all known tag handlers
+        root_element = Element.from_node(root)
+        viewbox, width, height = extract_root_dimensions(root)
+        clip_paths = ClipPathRegistry.from_node(root)
+        Document.new(root_element: root_element,
+                     viewbox: viewbox,
+                     width: width,
+                     height: height,
+                     clip_paths: clip_paths)
+      end
+
+      def self.extract_root_dimensions(root)
+        vb = root["viewBox"]
+        width = root["width"]
+        height = root["height"]
+        parsed_vb =
+          if vb
+            nums = vb.split(/\s+|,/).map(&:to_f)
+            nums if nums.length == 4
+          end
+        [parsed_vb, width&.to_f, height&.to_f]
+      end
+    end
+  end
+end

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

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Postsvg
+  module Svg
+    module PathData
+      # Single SVG path command. Opcode is upper-case (absolute) or
+      # lower-case (relative). +args+ is the raw numeric arguments.
+      Command = Struct.new(:opcode, :args, keyword_init: true) do
+        def absolute? = opcode == opcode.upcase
+
+        def relative? = opcode == opcode.downcase
+
+        def arity
+          case opcode.upcase
+          when "M", "L", "T" then 2
+          when "H", "V" then 1
+          when "C" then 6
+          when "S", "Q" then 4
+          when "A" then 7
+          when "Z" then 0
+          else 0
+          end
+        end
+      end
+    end
+  end
+end