stationery 0.2.0 → 0.3.0

data/lib/stationery/resources.rb

@@ -1,13 +1,14 @@
 # frozen_string_literal: true
 
 module Stationery
-  # Document-wide names for fonts, images and graphics states, so each is
+  # Document-wide names for fonts, images, graphics states and shadings, so each is
   # embedded once however many pages use it.
   class Resources
     def initialize
       @fonts = {}
       @images = {}
       @states = {}
+      @shadings = {}
     end
 
     def font(font)
@@ -22,12 +23,17 @@ module Stationery
       @states[value.to_f.round(3)] ||= :"GS#{@states.size + 1}"
     end
 
+    def shading(dictionary)
+      @shadings[dictionary] ||= :"Sh#{@shadings.size + 1}"
+    end
+
     # Writes every resource once; returns { category => { name => ref } }.
     def build(writer)
       {
         Font: @fonts.to_h { |font, name| [name, font.build(writer)] },
         XObject: @images.to_h { |image, name| [name, image.build(writer)] },
-        ExtGState: @states.to_h { |alpha, name| [name, writer.add({ Type: :ExtGState, ca: alpha, CA: alpha })] }
+        ExtGState: @states.to_h { |alpha, name| [name, writer.add({ Type: :ExtGState, ca: alpha, CA: alpha })] },
+        Shading: @shadings.to_h { |dictionary, name| [name, writer.add(dictionary)] }
       }
     end
   end

data/lib/stationery/svg/bounds.rb

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+module Stationery
+  module SVG
+    # A path sink that measures a shape's bounding box in its own user space,
+    # curves by their extrema. Takes the calls Shapes.trace makes on a path.
+    class Bounds
+      def initialize
+        @xs = []
+        @ys = []
+      end
+
+      def move_to(x, y) = add(x, y)
+      def line_to(x, y) = add(x, y)
+      def close = self
+
+      def curve_to(x1, y1, x2, y2, x, y)
+        x0 = @xs.last || 0
+        y0 = @ys.last || 0
+        (extrema(x0, x1, x2, x) + extrema(y0, y1, y2, y)).each do |at|
+          add(cubic(at, x0, x1, x2, x), cubic(at, y0, y1, y2, y))
+        end
+        add(x, y)
+      end
+
+      def rounded_rect(x, y, w, h, _radius)
+        add(x, y)
+        add(x + w, y + h)
+      end
+
+      def ellipse(cx, cy, rx, ry)
+        add(cx - rx, cy - ry)
+        add(cx + rx, cy + ry)
+      end
+
+      # [x, y, width, height], or nil when the shape has no area.
+      def box
+        return nil if @xs.empty?
+
+        width = @xs.max - @xs.min
+        height = @ys.max - @ys.min
+        [@xs.min, @ys.min, width, height] if width.positive? && height.positive?
+      end
+
+      private
+
+      def add(x, y)
+        @xs << x
+        @ys << y
+        self
+      end
+
+      # Parameters in (0, 1) where the cubic's derivative is zero.
+      def extrema(from, first, second, to)
+        a = -from + (3 * first) - (3 * second) + to
+        b = 2 * (from - (2 * first) + second)
+        c = first - from
+        roots(a, b, c).select { |t| t.positive? && t < 1 }
+      end
+
+      def roots(a, b, c)
+        return b.zero? ? [] : [-c.fdiv(b)] if a.zero?
+
+        discriminant = (b**2) - (4 * a * c)
+        return [] if discriminant.negative?
+
+        [1, -1].map { |sign| (-b + (sign * Math.sqrt(discriminant))) / (2.0 * a) }
+      end
+
+      def cubic(at, from, first, second, to)
+        rest = 1 - at
+        ((rest**3) * from) + (3 * (rest**2) * at * first) + (3 * rest * (at**2) * second) + ((at**3) * to)
+      end
+    end
+  end
+end

data/lib/stationery/svg/document.rb

@@ -5,10 +5,12 @@ module Stationery
     # A parsed SVG drawn as vector paths on a canvas. Supports the subset icon
     # sets use: path, rect (with rx), circle, ellipse, line, polyline, polygon
     # and g, with fill, stroke, stroke width/caps/joins, fill-rule, opacity,
-    # inline styles and transforms. `currentColor` takes the colour you pass.
+    # inline styles, <style> stylesheets, transforms, linear/radial gradients
+    # and text/tspan. `currentColor` takes the colour you pass.
     class Document
       SHAPES = %w[path rect circle ellipse line polyline polygon].freeze
-      QUIET = (SHAPES + %w[svg g title desc metadata]).freeze
+      QUIET = (SHAPES + %w[svg g title desc metadata style defs linearGradient radialGradient stop text
+                           tspan]).freeze
 
       def self.parse(source)
         root = Parser.parse(source)
@@ -22,19 +24,26 @@ module Stationery
       def initialize(root)
         @root = root
         @view_box = read_view_box
-        @unsupported = element_names(root).uniq.sort - QUIET
+        @sheet = Stylesheet.parse(style_text)
+        @gradients = Gradient.collect(root, @sheet)
+        @unsupported = (element_names(root).uniq - QUIET).sort + approximations
       end
 
       def aspect = @view_box[2].to_f / @view_box[3]
 
-      # Scales the viewBox into the box (aspect ratio kept, centred).
-      def draw(canvas, x:, y:, width:, height:, color: "#000000")
+      # Scales the viewBox into the box (aspect ratio kept, centred). Text is
+      # drawn from `book` (bundled fonts when nil), unknown families in `family`.
+      def draw(canvas, x:, y:, width:, height:, color: "#000000", book: nil, family: nil)
         vx, vy, vw, vh = @view_box
         scale = [width.to_f / vw, height.to_f / vh].min
         e = x + ((width - (vw * scale)) / 2.0) - (vx * scale)
         f = y + ((height - (vh * scale)) / 2.0) - (vy * scale)
-        style = Style.new(Style::DEFAULTS, [scale, 0, 0, scale, e, f], color:).child(@root.attributes)
-        @root.children.each { |element| draw_element(canvas, element, style) }
+        style = Style.new(Style::DEFAULTS, [scale, 0, 0, scale, e, f], color:, sheet: @sheet).child(@root)
+        painter = Painter.new(canvas, @gradients, @view_box.last(2))
+        text = Text.new(canvas, painter, book || Fonts::FontBook.new, family || Fonts::Bundled::DEFAULT)
+        shapes(@root, style) do |element, own|
+          element.name == "text" ? text.draw(element, own) : painter.paint(element, own)
+        end
       end
 
       private
@@ -46,8 +55,14 @@ module Stationery
         [0, 0, number(@root.attributes.fetch("width", "100")), number(@root.attributes.fetch("height", "100"))]
       end
 
+      def style_text
+        styles = []
+        Parser.walk(@root) { |element| styles << element if element.name == "style" }
+        styles.flat_map(&:children).join(" ")
+      end
+
       def element_names(element)
-        element.children.flat_map { |child| [child.name, *element_names(child)] }
+        element.children.grep(Parser::Element).flat_map { |child| [child.name, *element_names(child)] }
       end
 
       def number(value)
@@ -55,18 +70,33 @@ module Stationery
         float == float.round ? float.round : float
       end
 
-      def draw_element(canvas, element, parent)
-        style = parent.child(element.attributes)
-        return element.children.each { |child| draw_element(canvas, child, style) } if element.name == "g"
-        return unless SHAPES.include?(element.name)
+      # Yields every drawn shape and text with its resolved style, in paint
+      # order, skipping undisplayed subtrees and hidden elements.
+      def shapes(parent, parent_style, &)
+        parent.children.each do |element|
+          style = parent_style.child(element)
+          next unless style.displayed?
 
-        fill = style.fill
-        stroke = style.stroke
-        return if fill.nil? && stroke.nil?
+          if element.name == "g" then shapes(element, style, &)
+          elsif (SHAPES.include?(element.name) || element.name == "text") && style.visible? then yield element, style
+          end
+        end
+      end
 
-        canvas.path(fill:, stroke:, line_width: style.line_width, cap: style.cap || :butt, join: style.join || :miter,
-                    even_odd: style.even_odd?, opacity: style.opacity < 1 ? style.opacity : nil,
-                    transform: style.matrix) { |path| Shapes.trace(path, element) }
+      # Paint references to missing gradients, gradient spreads drawn as pad
+      # and stylesheet selectors ignored.
+      def approximations
+        missing = []
+        shapes(@root, Style.new(sheet: @sheet).child(@root)) do |_element, style|
+          [style.fill, style.stroke].grep(Style::Reference).each do |reference|
+            missing << "url(##{reference.id})" unless @gradients.key?(reference.id)
+          end
+        end
+        spreads = @gradients.values.filter_map do |gradient|
+          "#{gradient.kind}Gradient spreadMethod=#{gradient.approximated_spread}" if gradient.approximated_spread
+        end
+        selectors = @sheet.unsupported.empty? ? [] : ["style selectors: #{@sheet.unsupported.join(", ")}"]
+        (missing + spreads).uniq.sort + selectors
       end
     end
   end

data/lib/stationery/svg/gradient.rb

@@ -0,0 +1,115 @@
+# frozen_string_literal: true
+
+module Stationery
+  module SVG
+    # A linearGradient or radialGradient paint server, with the stops and
+    # attributes it inherits through `href`. Coordinates are in gradient
+    # space; `matrix` maps them into the painted element's user space.
+    class Gradient
+      KINDS = %w[linearGradient radialGradient].freeze
+      INHERITED = %w[x1 y1 x2 y2 cx cy r fx fy gradientUnits gradientTransform spreadMethod].freeze
+      SPREADS = %w[reflect repeat].freeze
+
+      Stop = Data.define(:offset, :color, :opacity)
+
+      # Every gradient in the document, by id; stops take `sheet` rules.
+      def self.collect(root, sheet = Stylesheet::EMPTY)
+        elements = {}
+        Parser.walk(root) { |element| elements[element.attributes["id"]] = element if KINDS.include?(element.name) }
+        elements.delete(nil)
+        elements.transform_values { |element| new(element, elements, sheet) }
+      end
+
+      attr_reader :kind, :attributes, :stops
+
+      def initialize(element, elements, sheet = Stylesheet::EMPTY)
+        @sheet = sheet
+        @kind = element.name == "radialGradient" ? :radial : :linear
+        chain = lineage(element, elements)
+        @attributes = chain.reverse.map { |link| link.attributes.slice(*INHERITED) }.reduce({}, :merge)
+        @stops = read_stops(chain.find { |link| stop_elements(link).any? })
+      end
+
+      def bounding_box? = @attributes["gradientUnits"] != "userSpaceOnUse"
+
+      def approximated_spread
+        spread = @attributes["spreadMethod"]
+        spread if SPREADS.include?(spread)
+      end
+
+      # Gradient space to user space, for a shape whose box is [x, y, w, h].
+      def matrix(box)
+        own = Transform.parse(@attributes["gradientTransform"].to_s)
+        return own unless bounding_box?
+
+        x, y, w, h = box
+        Transform.multiply([w, 0, 0, h, x, y], own)
+      end
+
+      # Axial [x1 y1 x2 y2] or radial [fx fy 0 cx cy r] coordinates; user
+      # space percentages resolve against the viewport [width, height].
+      def coords(viewport)
+        width, height = viewport
+        if @kind == :linear
+          return [length("x1", 0, width), length("y1", 0, height), length("x2", "100%", width), length("y2", 0, height)]
+        end
+
+        cx = length("cx", "50%", width)
+        cy = length("cy", "50%", height)
+        [length("fx", cx, width), length("fy", cy, height), 0, cx, cy,
+         length("r", "50%", Math.sqrt(((width**2) + (height**2)) / 2.0))]
+      end
+
+      # The interpolated colour at `offset` as "#RRGGBB".
+      def color_at(offset, current)
+        before = @stops.reverse.find { |stop| stop.offset <= offset } || @stops.first
+        after = @stops.find { |stop| stop.offset >= offset } || @stops.last
+        span = after.offset - before.offset
+        t = span.positive? ? (offset - before.offset) / span : 0
+        from, to = [before, after].map { |stop| rgb(stop, current) }
+        "##{from.zip(to).map { |a, b| format("%02X", ((a + ((b - a) * t)) * 255).round) }.join}"
+      end
+
+      def rgb(stop, current) = Color.parse(Style.color(stop.color, current)).components
+
+      private
+
+      def lineage(element, elements)
+        chain = [element]
+        while (id = reference(chain.last)) && (parent = elements[id]) && !chain.include?(parent)
+          chain << parent
+        end
+        chain
+      end
+
+      def reference(element)
+        (element.attributes["href"] || element.attributes["xlink:href"]).to_s[/\A#(.+)/, 1]
+      end
+
+      def stop_elements(element)
+        element.children.select { |child| child.is_a?(Parser::Element) && child.name == "stop" }
+      end
+
+      def read_stops(element)
+        return [] unless element
+
+        floor = 0.0
+        stop_elements(element).map do |stop|
+          values = stop.attributes.merge(@sheet.declarations(stop), Style.declarations(stop.attributes["style"]))
+          floor = [floor, fraction(values.fetch("offset", "0")).clamp(0.0, 1.0)].max
+          Stop.new(floor, values.fetch("stop-color", "black"), values.fetch("stop-opacity", "1").to_f)
+        end
+      end
+
+      def length(key, default, reference)
+        value = @attributes.fetch(key, default)
+        return value.to_f if value.is_a?(Numeric)
+        return value.to_f unless value.strip.end_with?("%")
+
+        bounding_box? ? value.to_f / 100 : value.to_f * reference / 100
+      end
+
+      def fraction(value) = value.strip.end_with?("%") ? value.to_f / 100 : value.to_f
+    end
+  end
+end

data/lib/stationery/svg/painter.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+module Stationery
+  module SVG
+    # Paints one shape element. Solid fills and strokes are one path; a
+    # gradient fill is a shading clipped to the shape, drawn under the
+    # stroke. A gradient stroke is drawn in the gradient's middle colour.
+    class Painter
+      def self.translucent(opacity) = opacity < 1 ? opacity : nil
+
+      def initialize(canvas, gradients, viewport)
+        @canvas = canvas
+        @gradients = gradients
+        @viewport = viewport
+      end
+
+      def paint(element, style)
+        fill = resolve(style.fill)
+        stroke = color(style.stroke, style)
+        if fill.is_a?(Gradient)
+          shade(element, style, fill)
+          fill = nil
+        end
+        return if fill.nil? && stroke.nil?
+
+        @canvas.path(fill:, stroke:, line_width: style.line_width, cap: style.cap || :butt, join: style.join || :miter,
+                     even_odd: style.even_odd?, opacity: Painter.translucent(style.opacity),
+                     transform: style.matrix) { |path| Shapes.trace(path, element) }
+      end
+
+      # A paint as one colour: a gradient's middle colour, nil for none.
+      def color(paint, style)
+        paint = resolve(paint)
+        paint.is_a?(Gradient) ? paint.color_at(0.5, style.color) : paint
+      end
+
+      private
+
+      def resolve(paint)
+        return paint unless paint.is_a?(Style::Reference)
+
+        gradient = @gradients[paint.id]
+        return paint.fallback unless gradient
+        return nil if gradient.stops.empty?
+
+        gradient
+      end
+
+      # Stops with differing opacities are approximated by the first one's.
+      def shade(element, style, gradient)
+        opacity = Painter.translucent(style.opacity * gradient.stops.first.opacity)
+        return single_stop(element, style, gradient, opacity) if gradient.stops.one?
+
+        box = Bounds.new.tap { |bounds| Shapes.trace(bounds, element) }.box
+        return if gradient.bounding_box? && box.nil?
+
+        shading = Shading.dictionary(gradient, gradient.coords(@viewport), style.color)
+        matrix = Transform.multiply(style.matrix, gradient.matrix(box))
+        @canvas.shade(shading, matrix:, transform: style.matrix, even_odd: style.even_odd?, opacity:) do |path|
+          Shapes.trace(path, element)
+        end
+      end
+
+      def single_stop(element, style, gradient, opacity)
+        @canvas.path(fill: gradient.color_at(0, style.color), even_odd: style.even_odd?, opacity:,
+                     transform: style.matrix) { |path| Shapes.trace(path, element) }
+      end
+    end
+  end
+end

data/lib/stationery/svg/parser.rb

@@ -5,27 +5,47 @@ require "strscan"
 module Stationery
   module SVG
     # A minimal XML reader for SVG documents: elements, attributes and nesting.
-    # Comments, processing instructions, doctypes and text content are skipped.
+    # Comments, processing instructions and doctypes are skipped; text content
+    # (CDATA included) is kept only inside text, tspan and style, as String
+    # children with entities decoded and each whitespace run one space.
     module Parser
       Element = Data.define(:name, :attributes, :children)
 
-      IGNORED = /<!--.*?-->|<\?.*?\?>|<!DOCTYPE[^>]*>|<!\[CDATA\[.*?\]\]>/m
+      TEXT = %w[text tspan style].freeze
+
+      IGNORED = /<!--.*?-->|<\?.*?\?>|<!DOCTYPE[^>]*>/m
+      CDATA = /<!\[CDATA\[(.*?)\]\]>/m
+      ESCAPES = { "&" => "&amp;", "<" => "&lt;", ">" => "&gt;" }.freeze
       TAG = %r{<(/?)([a-zA-Z][\w:.-]*)((?:\s+[\w:.-]+\s*=\s*(?:"[^"]*"|'[^']*'))*)\s*(/?)>}m
       ATTRIBUTE = /([\w:.-]+)\s*=\s*(?:"([^"]*)"|'([^']*)')/
 
       module_function
 
       def parse(source)
-        scanner = StringScanner.new(source.to_s.gsub(IGNORED, ""))
+        source = source.to_s.gsub(IGNORED, "").gsub(CDATA) { Regexp.last_match(1).gsub(/[&<>]/, ESCAPES) }
+        scanner = StringScanner.new(source)
         root = Element.new("document", {}, [])
         stack = [root]
-        while scanner.skip_until(/(?=<)/)
+        while (content = scanner.scan_until(/(?=<)/))
+          keep(stack.last, content)
           tag = scanner.scan(TAG) or (scanner.getch && next)
           handle(stack, *tag.match(TAG).captures)
         end
         root.children.first
       end
 
+      # Yields the element and every element below it, depth first.
+      def walk(element, &)
+        yield element
+        element.children.each { |child| walk(child, &) if child.is_a?(Element) }
+      end
+
+      def keep(element, content)
+        return if content.empty? || !TEXT.include?(element.name)
+
+        element.children << Stationery::Text::Entities.decode(content).gsub(/\s+/, " ")
+      end
+
       def handle(stack, closing, name, attributes, self_closing)
         return stack.pop if closing == "/" && stack.size > 1
 

data/lib/stationery/svg/selector.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module Stationery
+  module SVG
+    # A compound CSS selector: an element name or `*`, then any number of
+    # `.class` and `#id` parts. Combinators, pseudo-classes and attribute
+    # selectors are not read.
+    class Selector
+      PATTERN = /\A(\*|[a-zA-Z][\w-]*)?((?:[.#][\w-]+)*)\z/
+
+      def self.parse(text)
+        match = text.match(PATTERN)
+        return nil if match.nil? || text.empty?
+
+        parts = match[2].scan(/[.#][\w-]+/)
+        new(match[1], parts.grep(/\A#/).map { |id| id[1..] }, parts.grep(/\A\./).map { |name| name[1..] })
+      end
+
+      def initialize(name, ids, classes)
+        @name = name == "*" ? nil : name
+        @ids = ids
+        @classes = classes
+      end
+
+      # [ids, classes, element names], compared in that order.
+      def specificity = [@ids.size, @classes.size, @name ? 1 : 0]
+
+      def match?(element)
+        attributes = element.attributes
+        return false if @name && @name != element.name
+        return false unless @ids.all?(attributes["id"])
+
+        (@classes - attributes["class"].to_s.split).empty?
+      end
+    end
+  end
+end

data/lib/stationery/svg/shading.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module Stationery
+  module SVG
+    # A gradient as a PDF shading dictionary: axial (type 2) or radial
+    # (type 3) in DeviceRGB, its stops as one exponential function or a
+    # stitching of one per pair. The ends always extend (spread `pad`).
+    module Shading
+      module_function
+
+      def dictionary(gradient, coords, current)
+        {
+          ShadingType: gradient.kind == :radial ? 3 : 2, ColorSpace: :DeviceRGB, Coords: coords,
+          Function: function(padded(gradient.stops), gradient, current), Extend: [true, true]
+        }
+      end
+
+      def function(stops, gradient, current)
+        colors = stops.map { |stop| gradient.rgb(stop, current).map { |v| v.round(4) } }
+        segments = colors.each_cons(2).map { |c0, c1| { FunctionType: 2, Domain: [0, 1], C0: c0, C1: c1, N: 1 } }
+        return segments.first if segments.one?
+
+        { FunctionType: 3, Domain: [0, 1], Functions: segments, Bounds: stops[1..-2].map(&:offset),
+          Encode: [0, 1] * segments.size }
+      end
+
+      def padded(stops)
+        stops = [stops.first.with(offset: 0.0), *stops] if stops.first.offset.positive?
+        stops = [*stops, stops.last.with(offset: 1.0)] if stops.last.offset < 1
+        stops
+      end
+    end
+  end
+end

data/lib/stationery/svg/style.rb

@@ -3,24 +3,47 @@
 module Stationery
   module SVG
     # Presentation attributes an element inherits from its ancestors, and the
-    # transform it draws with.
+    # transform it draws with. An element's own values cascade: presentation
+    # attributes, then stylesheet rules, then its inline `style`.
     class Style
       INHERITED = %w[fill stroke stroke-width stroke-linecap stroke-linejoin fill-rule opacity fill-opacity
-                     stroke-opacity].freeze
+                     stroke-opacity font-family font-size font-weight font-style text-anchor visibility].freeze
       NAMED = { "black" => "#000000", "white" => "#FFFFFF", "red" => "#FF0000", "green" => "#008000",
                 "blue" => "#0000FF", "gray" => "#808080", "grey" => "#808080" }.freeze
       DEFAULTS = { "fill" => "black", "stroke" => "none", "stroke-width" => "1" }.freeze
+      URL = /\Aurl\(\s*['"]?#([^'")\s]+)['"]?\s*\)\s*(.*)\z/
 
-      attr_reader :values, :matrix
+      # A paint server reference, `url(#id)`, with its fallback colour (or nil).
+      Reference = Data.define(:id, :fallback)
 
-      def initialize(values = DEFAULTS, matrix = [1, 0, 0, 1, 0, 0], color: "#000000")
+      def self.color(value, current)
+        value = value.to_s.strip
+        return current if value == "currentColor"
+
+        NAMED.fetch(value.downcase, value)
+      end
+
+      def self.declarations(style)
+        style.to_s.split(";").filter_map do |declaration|
+          key, value = declaration.split(":", 2).map(&:strip)
+          [key, value] if key && value
+        end.to_h
+      end
+
+      attr_reader :values, :matrix, :color
+
+      def initialize(values = DEFAULTS, matrix = [1, 0, 0, 1, 0, 0], color: "#000000", sheet: Stylesheet::EMPTY,
+                     display: nil)
         @values = values
         @matrix = matrix
         @color = color
+        @sheet = sheet
+        @display = display
       end
 
-      def child(attributes)
-        own = attributes.merge(declarations(attributes["style"]))
+      def child(element)
+        attributes = element.attributes
+        own = attributes.merge(@sheet.declarations(element), Style.declarations(attributes["style"]))
         values = @values.merge(own.slice(*INHERITED))
         matrix = if attributes["transform"]
                    Transform.multiply(@matrix,
@@ -28,9 +51,12 @@ module Stationery
                  else
                    @matrix
                  end
-        Style.new(values, matrix, color: @color)
+        Style.new(values, matrix, color: @color, sheet: @sheet, display: own["display"])
       end
 
+      def displayed? = @display != "none"
+      def visible? = !%w[hidden collapse].include?(@values["visibility"])
+
       def fill = paint("fill")
       def stroke = paint("stroke")
       def even_odd? = @values["fill-rule"] == "evenodd"
@@ -38,10 +64,7 @@ module Stationery
       def join = @values["stroke-linejoin"]&.to_sym
 
       # Stroke width scales with the drawing, by the transform's area factor.
-      def line_width
-        a, b, c, d, = @matrix
-        @values["stroke-width"].to_f * Math.sqrt(((a * d) - (b * c)).abs)
-      end
+      def line_width = @values["stroke-width"].to_f * Transform.scale(@matrix)
 
       def opacity
         %w[opacity fill-opacity stroke-opacity].filter_map { |key| @values[key]&.to_f }.reduce(1.0, :*)
@@ -52,16 +75,10 @@ module Stationery
       def paint(key)
         value = @values[key].to_s.strip
         return nil if value.empty? || %w[none transparent].include?(value)
-        return @color if value == "currentColor"
-
-        NAMED.fetch(value.downcase, value)
-      end
+        return Style.color(value, @color) unless (url = value.match(URL))
 
-      def declarations(style)
-        style.to_s.split(";").filter_map do |declaration|
-          key, value = declaration.split(":", 2).map(&:strip)
-          [key, value] if key && value
-        end.to_h
+        fallback = url[2]
+        Reference.new(url[1], fallback.empty? || fallback == "none" ? nil : Style.color(fallback, @color))
       end
     end
   end

data/lib/stationery/svg/stylesheet.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module Stationery
+  module SVG
+    # The rules of a document's <style> elements. An element's declarations
+    # are those of every matching rule, the more specific winning and the
+    # later winning among equals. At-rules are skipped and `!important` is
+    # read as a plain declaration; rules whose selectors use combinators are
+    # ignored and listed in #unsupported.
+    class Stylesheet
+      Rule = Data.define(:selector, :declarations, :index)
+
+      RULE = /([^{}]+)\{([^{}]*)\}/
+      COMMENT = %r{/\*.*?\*/}m
+
+      def self.parse(css)
+        rules = []
+        unsupported = []
+        css.gsub(COMMENT, "").scan(RULE).each do |selectors, body|
+          next if selectors.strip.start_with?("@")
+
+          declarations = Style.declarations(body).transform_values { |value| value.sub(/\s*!important\z/, "") }
+          selectors.split(",").map(&:strip).each do |text|
+            selector = Selector.parse(text)
+            selector ? rules << Rule.new(selector, declarations, rules.size) : unsupported << text
+          end
+        end
+        new(rules, unsupported)
+      end
+
+      attr_reader :unsupported
+
+      def initialize(rules, unsupported)
+        @rules = rules
+        @unsupported = unsupported
+      end
+
+      EMPTY = new([], []).freeze
+
+      def declarations(element)
+        @rules.select { |rule| rule.selector.match?(element) }
+              .sort_by { |rule| [rule.selector.specificity, rule.index] }
+              .reduce({}) { |merged, rule| merged.merge(rule.declarations) }
+      end
+    end
+  end
+end