prawn-svg 0.29.1 → 0.32.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2dbf86f272347e8867b1e7262a49163c316d0160fc35802ceb1f7b0f8ed90e25
-  data.tar.gz: 4244134c0616eaf4aa9ca8ef19bbde2137e589d4f3929dd30b55c4c3d5136c36
+  metadata.gz: d054ded3422dc4cd1cb870dc09549c0a82c1e2813e314565c7a3aec70d95d188
+  data.tar.gz: 123a00b97f78f284a8e11fad37fed42cbec06d678675ec15ff7dafbcfe6505d5
 SHA512:
-  metadata.gz: 3d1874a6766112c3084355c21b517b7a1d413f0e9e88c806cb236d69edc9fb7e1c3e253f13746c18e5e9b57d1221341d5c309494429dbae4a377ef91b99c8a52
-  data.tar.gz: bbd80743596ad9c2c25871c5c6542d2ddfb0c3026ac5d0efb61a894b501aabc6657e048f3d52b0b0e42e634e68b0d30f7e5096ce9bfdc81d4a7ffc7ac08d65e9
+  metadata.gz: 4ece284ced16e7b6f4d7562c17a97780375f4e255eb4199d489cfb1fa473dc1f65e6b9fa48894079f0756b42a749cc58f34c00507e19ccdfddab55723c82311d
+  data.tar.gz: 8826f6f457372cc7df38869e6448974f5731fdee1040bca44b8446b71c57e0713340481a3400705c8fd11ec5d13959dcd99f24a0fe8820c89a37ca725545656c

data/.github/workflows/test.yml

@@ -0,0 +1,18 @@
+name: test
+on: [push, pull_request]
+jobs:
+  rake:
+    runs-on: ubuntu-latest
+    strategy:
+      fail-fast: false
+      matrix:
+        ruby: [2.3, 2.4, 2.5, 2.6, 2.7, '3.0']
+    steps:
+    - uses: actions/checkout@v2
+    - name: Set up Ruby
+      uses: ruby/setup-ruby@v1
+      with:
+        bundler-cache: true
+        ruby-version: ${{ matrix.ruby }}
+    - name: Run tests
+      run:  bundle exec rake

data/LICENSE

@@ -1,6 +1,6 @@
 The MIT License
 
-Copyright 2010-2013 Roger Nesbitt
+Copyright 2010-2019 Roger Nesbitt
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

data/README.md

@@ -1,7 +1,7 @@
 # prawn-svg
 
 [![Gem Version](https://badge.fury.io/rb/prawn-svg.svg)](https://badge.fury.io/rb/prawn-svg)
-[![Build Status](https://travis-ci.org/mogest/prawn-svg.svg?branch=master)](https://travis-ci.org/mogest/prawn-svg)
+![Build Status](https://github.com/mogest/prawn-svg/actions/workflows/test.yml/badge.svg?branch=master)
 
 An SVG renderer for the Prawn PDF library.
 
@@ -10,7 +10,7 @@ This will take an SVG document as input and render it into your PDF.  Find out m
   http://github.com/prawnpdf/prawn
 
 prawn-svg is compatible with all versions of Prawn from 0.11.1 onwards, including the 1.x and 2.x series.
-The minimum Ruby version required is 2.1.0.
+The minimum Ruby version required is 2.3.0.
 
 ## Using prawn-svg
 
@@ -60,8 +60,8 @@ prawn-svg supports most but not all of the full SVG 1.1 specification.  It curre
  - <tt>&lt;path&gt;</tt> supports all commands defined in SVG 1.1, although the
    implementation of elliptical arc is a bit rough at the moment.
 
- - `<text>`, `<tspan>` and `<tref>` with attributes `x`, `y`, `dx`, `dy`, `rotate`, and with extra properties
-   `text-anchor`, `font-size`, `font-family`, `font-weight`, `font-style`, `letter-spacing`
+ - `<text>`, `<tspan>` and `<tref>` with attributes `x`, `y`, `dx`, `dy`, `rotate`, 'textLength', 'lengthAdjust', and with extra properties
+   `text-anchor`, `text-decoration` (underline only), `font-size`, `font-family`, `font-weight`, `font-style`, `letter-spacing`
 
  - <tt>&lt;svg&gt;</tt>, <tt>&lt;g&gt;</tt> and <tt>&lt;symbol&gt;</tt>
 
@@ -76,7 +76,7 @@ prawn-svg supports most but not all of the full SVG 1.1 specification.  It curre
 
  - `<marker>`
 
- - `<linearGradient>` is implemented with Prawn 2.2.0+ (gradientTransform, spreadMethod and stop-opacity are unimplemented.)
+ - `<linearGradient>` and `<radialGradient>` are implemented on Prawn 2.2.0+ with attributes `gradientUnits` and `gradientTransform` (spreadMethod and stop-opacity are unimplemented.)
 
  - `<switch>` and `<foreignObject>`, although prawn-svg cannot handle any data that is not SVG so `<foreignObject>`
    tags are always ignored.
@@ -91,7 +91,7 @@ prawn-svg supports most but not all of the full SVG 1.1 specification.  It curre
 
  - the <tt>preserveAspectRatio</tt> attribute on <tt>&lt;svg&gt;</tt>, <tt>&lt;image&gt;</tt> and `<marker>` elements
 
- - transform methods: <tt>translate()</tt>, <tt>rotate()</tt>, <tt>scale()</tt>, <tt>matrix()</tt>
+ - transform methods: `translate`, `translateX`, `translateY`, `rotate`, `scale`, `skewX`, `skewY`, `matrix`
 
  - colors: HTML standard names, <tt>#xxx</tt>, <tt>#xxxxxx</tt>, <tt>rgb(1, 2, 3)</tt>, <tt>rgb(1%, 2%, 3%)</tt>
 
@@ -116,7 +116,7 @@ implemented, but `!important` is not.
 
 ## Not supported
 
-prawn-svg does not support radial gradients, patterns or filters.
+prawn-svg does not support hyperlinks, patterns or filters.
 
 It does not support text in the clip area, but you can clip shapes and text by any shape.
 
@@ -135,5 +135,6 @@ Mac OS X and Debian Linux users.  You can add to the font path:
 
 In your Gemfile, put `gem 'prawn-svg'` before `gem 'prawn-rails'` so that prawn-rails can see the prawn-svg extension.
 
---
-Copyright Roger Nesbitt <roger@seriousorange.com>.  MIT licence.
+## Licence
+
+MIT licence.  Copyright Roger Nesbitt.

data/lib/prawn/svg/attributes/opacity.rb

@@ -1,13 +1,13 @@
 module Prawn::SVG::Attributes::Opacity
   def parse_opacity_attributes_and_call
     # We can't do nested opacities quite like the SVG requires, but this is close enough.
-    fill_opacity = stroke_opacity = clamp(properties.opacity.to_f, 0, 1) if properties.opacity
+    opacity = clamp(properties.opacity.to_f, 0, 1) if properties.opacity
     fill_opacity = clamp(properties.fill_opacity.to_f, 0, 1) if properties.fill_opacity
     stroke_opacity = clamp(properties.stroke_opacity.to_f, 0, 1) if properties.stroke_opacity
 
-    if fill_opacity || stroke_opacity
-      state.fill_opacity *= fill_opacity || 1
-      state.stroke_opacity *= stroke_opacity || 1
+    if opacity || fill_opacity || stroke_opacity
+      state.fill_opacity *= [opacity || 1, fill_opacity || 1].min
+      state.stroke_opacity *= [opacity || 1, stroke_opacity || 1].min
 
       add_call_and_enter 'transparent', state.fill_opacity, state.stroke_opacity
     end

data/lib/prawn/svg/attributes/transform.rb

@@ -2,49 +2,7 @@ module Prawn::SVG::Attributes::Transform
   def parse_transform_attribute_and_call
     return unless transform = attributes['transform']
 
-    parse_css_method_calls(transform).each do |name, arguments|
-      case name
-      when 'translate'
-        x, y = arguments
-        add_call_and_enter name, x_pixels(x.to_f), -y_pixels(y.to_f)
-
-      when 'rotate'
-        r, x, y = arguments.collect {|a| a.to_f}
-        case arguments.length
-        when 1
-          add_call_and_enter name, -r, :origin => [0, y('0')]
-        when 3
-          add_call_and_enter name, -r, :origin => [x(x), y(y)]
-        else
-          warnings << "transform 'rotate' must have either one or three arguments"
-        end
-
-      when 'scale'
-        x_scale = arguments[0].to_f
-        y_scale = (arguments[1] || x_scale).to_f
-        add_call_and_enter "transformation_matrix", x_scale, 0, 0, y_scale, 0, 0
-
-      when 'matrix'
-        if arguments.length != 6
-          warnings << "transform 'matrix' must have six arguments"
-        else
-          a, b, c, d, e, f = arguments.collect {|argument| argument.to_f}
-          add_call_and_enter "transformation_matrix", a, -b, -c, d, x_pixels(e), -y_pixels(f)
-        end
-
-      else
-        warnings << "Unknown transformation '#{name}'; ignoring"
-      end
-    end
-  end
-
-  private
-
-  def parse_css_method_calls(string)
-    string.scan(/\s*(\w+)\(([^)]+)\)\s*/).collect do |call|
-      name, argument_string = call
-      arguments = argument_string.strip.split(/\s*[,\s]\s*/)
-      [name, arguments]
-    end
+    matrix = parse_transform_attribute(transform)
+    add_call_and_enter "transformation_matrix", *matrix unless matrix == [1, 0, 0, 1, 0, 0]
   end
 end

data/lib/prawn/svg/elements/base.rb

@@ -11,6 +11,8 @@ class Prawn::SVG::Elements::Base
   include Prawn::SVG::Attributes::Stroke
   include Prawn::SVG::Attributes::Space
 
+  include Prawn::SVG::TransformParser
+
   PAINT_TYPES = %w(fill stroke)
   COMMA_WSP_REGEXP = Prawn::SVG::Elements::COMMA_WSP_REGEXP
   SVG_NAMESPACE = "http://www.w3.org/2000/svg"
@@ -89,12 +91,12 @@ class Prawn::SVG::Elements::Base
     parse_xml_space_attribute
   end
 
-  def add_call(name, *arguments)
-    @calls << [name.to_s, arguments, []]
+  def add_call(name, *arguments, **kwarguments)
+    @calls << [name.to_s, arguments, kwarguments, []]
   end
 
-  def add_call_and_enter(name, *arguments)
-    @calls << [name.to_s, arguments, []]
+  def add_call_and_enter(name, *arguments, **kwarguments)
+    @calls << [name.to_s, arguments, kwarguments, []]
     @calls = @calls.last.last
   end
 
@@ -166,7 +168,7 @@ class Prawn::SVG::Elements::Base
       command = stroke ? 'fill_and_stroke' : 'fill'
 
       if computed_properties.fill_rule == 'evenodd'
-        add_call_and_enter(command, {fill_rule: :even_odd})
+        add_call_and_enter(command, fill_rule: :even_odd)
       else
         add_call_and_enter(command)
       end
@@ -265,4 +267,8 @@ class Prawn::SVG::Elements::Base
     element = document.elements_by_id[matches[1]] if matches
     element if element && (expected_type.nil? || element.name == expected_type)
   end
+
+  def href_attribute
+    attributes['xlink:href'] || attributes['href']
+  end
 end

data/lib/prawn/svg/elements/call_duplicator.rb

@@ -12,7 +12,7 @@ module Prawn::SVG::Elements::CallDuplicator
   end
 
   def duplicate_call(call)
-    [call[0], duplicate_array(call[1]), duplicate_calls(call[2])]
+    [call[0], duplicate_array(call[1]), duplicate_hash(call[2]), duplicate_calls(call[3])]
   end
 
   def duplicate_array(array)

data/lib/prawn/svg/elements/gradient.rb

@@ -1,10 +1,18 @@
 class Prawn::SVG::Elements::Gradient < Prawn::SVG::Elements::Base
-  TAG_NAME_TO_TYPE = {"linearGradient" => :linear}
+  attr_reader :parent_gradient
+  attr_reader :x1, :y1, :x2, :y2, :cx, :cy, :fx, :fy, :radius, :units, :stops, :transform_matrix
+
+  TAG_NAME_TO_TYPE = {
+    "linearGradient" => :linear,
+    "radialGradient" => :radial
+  }
 
   def parse
     # A gradient tag without an ID is inaccessible and can never be used
     raise SkipElementQuietly if attributes['id'].nil?
 
+    @parent_gradient = document.gradients[href_attribute[1..-1]] if href_attribute && href_attribute[0] == '#'
+
     assert_compatible_prawn_version
     load_gradient_configuration
     load_coordinates
@@ -16,26 +24,56 @@ class Prawn::SVG::Elements::Gradient < Prawn::SVG::Elements::Base
   end
 
   def gradient_arguments(element)
-    case @units
-    when :bounding_box
-      x1, y1, x2, y2 = element.bounding_box
-      return if y2.nil?
+    # Passing in a transformation matrix to the apply_transformations option is supported
+    # by a monkey patch installed by prawn-svg.  Prawn only sees this as a truthy variable.
+    #
+    # See Prawn::SVG::Extensions::AdditionalGradientTransforms for details.
+    base_arguments = {stops: stops, apply_transformations: transform_matrix || true}
+
+    arguments = specific_gradient_arguments(element)
+    arguments.merge(base_arguments) if arguments
+  end
 
-      width = x2 - x1
-      height = y1 - y2
+  private
 
-      from = [x1 + width * @x1, y1 - height * @y1]
-      to   = [x1 + width * @x2, y1 - height * @y2]
+  def specific_gradient_arguments(element)
+    if units == :bounding_box
+      bounding_x1, bounding_y1, bounding_x2, bounding_y2 = element.bounding_box
+      return if bounding_y2.nil?
 
-    when :user_space
-      from = [@x1, @y1]
-      to   = [@x2, @y2]
+      width = bounding_x2 - bounding_x1
+      height = bounding_y1 - bounding_y2
     end
 
-    {from: from, to: to, stops: @stops}
-  end
+    case [type, units]
+    when [:linear, :bounding_box]
+      from = [bounding_x1 + width * x1, bounding_y1 - height * y1]
+      to   = [bounding_x1 + width * x2, bounding_y1 - height * y2]
 
-  private
+      {from: from, to: to}
+
+    when [:linear, :user_space]
+      {from: [x1, y1], to: [x2, y2]}
+
+    when [:radial, :bounding_box]
+      center = [bounding_x1 + width * cx, bounding_y1 - height * cy]
+      focus  = [bounding_x1 + width * fx, bounding_y1 - height * fy]
+
+      # Note: Chrome, at least, implements radial bounding box radiuses as
+      # having separate X and Y components, so in bounding box mode their
+      # gradients come out as ovals instead of circles.  PDF radial shading
+      # doesn't have the option to do this, and it's confusing why the
+      # Chrome user space gradients don't apply the same logic anyway.
+      hypot = Math.sqrt(width * width + height * height)
+      {from: focus, r1: 0, to: center, r2: radius * hypot}
+
+    when [:radial, :user_space]
+      {from: [fx, fy], r1: 0, to: [cx, cy], r2: radius}
+
+    else
+      raise "unexpected type/unit system"
+    end
+  end
 
   def type
     TAG_NAME_TO_TYPE.fetch(name)
@@ -51,10 +89,7 @@ class Prawn::SVG::Elements::Gradient < Prawn::SVG::Elements::Base
     @units = attributes["gradientUnits"] == 'userSpaceOnUse' ? :user_space : :bounding_box
 
     if transform = attributes["gradientTransform"]
-      matrix = transform.split(COMMA_WSP_REGEXP).map(&:to_f)
-      if matrix != [1, 0, 0, 1, 0, 0]
-        raise SkipElementError, "prawn-svg does not yet support gradients with a non-identity gradientTransform attribute"
-      end
+      @transform_matrix = parse_transform_attribute(transform)
     end
 
     if (spread_method = attributes['spreadMethod']) && spread_method != "pad"
@@ -63,18 +98,35 @@ class Prawn::SVG::Elements::Gradient < Prawn::SVG::Elements::Base
   end
 
   def load_coordinates
-    case @units
-    when :bounding_box
+    case [type, units]
+    when [:linear, :bounding_box]
       @x1 = parse_zero_to_one(attributes["x1"], 0)
       @y1 = parse_zero_to_one(attributes["y1"], 0)
       @x2 = parse_zero_to_one(attributes["x2"], 1)
       @y2 = parse_zero_to_one(attributes["y2"], 0)
 
-    when :user_space
+    when [:linear, :user_space]
       @x1 = x(attributes["x1"])
       @y1 = y(attributes["y1"])
       @x2 = x(attributes["x2"])
       @y2 = y(attributes["y2"])
+
+    when [:radial, :bounding_box]
+      @cx = parse_zero_to_one(attributes["cx"], 0.5)
+      @cy = parse_zero_to_one(attributes["cy"], 0.5)
+      @fx = parse_zero_to_one(attributes["fx"], cx)
+      @fy = parse_zero_to_one(attributes["fy"], cy)
+      @radius = parse_zero_to_one(attributes["r"], 0.5)
+
+    when [:radial, :user_space]
+      @cx = x(attributes["cx"] || '50%')
+      @cy = y(attributes["cy"] || '50%')
+      @fx = x(attributes["fx"] || attributes["cx"])
+      @fy = y(attributes["fy"] || attributes["cy"])
+      @radius = pixels(attributes["r"] || '50%')
+
+    else
+      raise "unexpected type/unit system"
     end
   end
 
@@ -100,10 +152,16 @@ class Prawn::SVG::Elements::Gradient < Prawn::SVG::Elements::Base
       end
     end
 
-    raise SkipElementError, "gradient does not have any valid stops" if @stops.empty?
+    if stops.empty?
+      if parent_gradient.nil? || parent_gradient.stops.empty?
+        raise SkipElementError, "gradient does not have any valid stops"
+      end
 
-    @stops.unshift([0, @stops.first.last]) if @stops.first.first > 0
-    @stops.push([1, @stops.last.last])     if @stops.last.first  < 1
+      @stops = parent_gradient.stops
+    else
+      stops.unshift([0, stops.first.last]) if stops.first.first > 0
+      stops.push([1, stops.last.last])     if stops.last.first  < 1
+    end
   end
 
   def parse_zero_to_one(string, default = 0)

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

@@ -15,9 +15,9 @@ class Prawn::SVG::Elements::Image < Prawn::SVG::Elements::Base
 
     raise SkipElementQuietly if state.computed_properties.display == "none"
 
-    @url = attributes['xlink:href'] || attributes['href']
+    @url = href_attribute
     if @url.nil?
-      raise SkipElementError, "image tag must have an xlink:href"
+      raise SkipElementError, "image tag must have an href or xlink:href"
     end
 
     x = x(attributes['x'] || 0)

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

@@ -4,10 +4,31 @@ class Prawn::SVG::Elements::Path < Prawn::SVG::Elements::Base
 
   INSIDE_SPACE_REGEXP = /[ \t\r\n,]*/
   OUTSIDE_SPACE_REGEXP = /[ \t\r\n]*/
-  INSIDE_REGEXP = /#{INSIDE_SPACE_REGEXP}([+-]?(?:[0-9]+(?:\.[0-9]*)?|\.[0-9]+)(?:(?<=[0-9])[eE][+-]?[0-9]+)?)/
-  VALUES_REGEXP = /^#{INSIDE_REGEXP}/
+  INSIDE_REGEXP = /#{INSIDE_SPACE_REGEXP}(?>([+-]?(?:[0-9]+(?:\.[0-9]*)?|\.[0-9]+)(?:(?<=[0-9])[eE][+-]?[0-9]+)?))/
+  FLAG_REGEXP = /#{INSIDE_SPACE_REGEXP}([01])/
   COMMAND_REGEXP = /^#{OUTSIDE_SPACE_REGEXP}([A-Za-z])((?:#{INSIDE_REGEXP})*)#{OUTSIDE_SPACE_REGEXP}/
 
+  A_PARAMETERS_REGEXP = /^#{INSIDE_REGEXP}#{INSIDE_REGEXP}#{INSIDE_REGEXP}#{FLAG_REGEXP}#{FLAG_REGEXP}#{INSIDE_REGEXP}#{INSIDE_REGEXP}/
+  ONE_PARAMETER_REGEXP = /^#{INSIDE_REGEXP}/
+  TWO_PARAMETER_REGEXP = /^#{INSIDE_REGEXP}#{INSIDE_REGEXP}/
+  FOUR_PARAMETER_REGEXP = /^#{INSIDE_REGEXP}#{INSIDE_REGEXP}#{INSIDE_REGEXP}#{INSIDE_REGEXP}/
+  SIX_PARAMETER_REGEXP = /^#{INSIDE_REGEXP}#{INSIDE_REGEXP}#{INSIDE_REGEXP}#{INSIDE_REGEXP}#{INSIDE_REGEXP}#{INSIDE_REGEXP}/
+
+  COMMAND_MATCH_MAP = {
+    'A' => A_PARAMETERS_REGEXP,
+    'C' => SIX_PARAMETER_REGEXP,
+    'H' => ONE_PARAMETER_REGEXP,
+    'L' => TWO_PARAMETER_REGEXP,
+    'M' => TWO_PARAMETER_REGEXP,
+    'Q' => FOUR_PARAMETER_REGEXP,
+    'S' => FOUR_PARAMETER_REGEXP,
+    'T' => TWO_PARAMETER_REGEXP,
+    'V' => ONE_PARAMETER_REGEXP,
+    'Z' => //,
+  }
+
+  PARAMETERLESS_COMMANDS = COMMAND_MATCH_MAP.select { |_, v| v == // }.map(&:first)
+
   FLOAT_ERROR_DELTA = 1e-10
 
   attr_reader :commands
@@ -16,20 +37,20 @@ class Prawn::SVG::Elements::Path < Prawn::SVG::Elements::Base
     require_attributes 'd'
 
     @commands = []
+    @last_point = nil
 
     data = attributes["d"].gsub(/#{OUTSIDE_SPACE_REGEXP}$/, '')
 
     matched_commands = match_all(data, COMMAND_REGEXP)
     raise SkipElementError, "Invalid/unsupported syntax for SVG path data" if matched_commands.nil?
 
-    catch :invalid_command do
-      matched_commands.each do |matched_command|
-        command = matched_command[1]
-        matched_values = match_all(matched_command[2], VALUES_REGEXP)
-        raise "should be impossible to have invalid inside data, but we ended up here" if matched_values.nil?
-        values = matched_values.collect {|value| value[1].to_f}
-        parse_path_command(command, values)
-      end
+    matched_commands.each do |(command, parameters)|
+      regexp = COMMAND_MATCH_MAP[command.upcase] or break
+      matched_values = match_all(parameters, regexp) or break
+      values = matched_values.map { |value| value.map(&:to_f) }
+      break if values.empty? && !PARAMETERLESS_COMMANDS.include?(command.upcase)
+
+      parse_path_command(command, values)
     end
   end
 
@@ -48,8 +69,7 @@ class Prawn::SVG::Elements::Path < Prawn::SVG::Elements::Base
 
     case upcase_command
     when 'M' # moveto
-      x = values.shift or throw :invalid_command
-      y = values.shift or throw :invalid_command
+      x, y = values.shift
 
       if relative && @last_point
         x += @last_point.first
@@ -68,8 +88,7 @@ class Prawn::SVG::Elements::Path < Prawn::SVG::Elements::Base
 
     when 'L' # lineto
       while values.any?
-        x = values.shift
-        y = values.shift or throw :invalid_command
+        x, y = values.shift
         if relative && @last_point
           x += @last_point.first
           y += @last_point.last
@@ -80,22 +99,21 @@ class Prawn::SVG::Elements::Path < Prawn::SVG::Elements::Base
 
     when 'H' # horizontal lineto
       while values.any?
-        x = values.shift
+        x = values.shift.first
         x += @last_point.first if relative && @last_point
         push_command Prawn::SVG::Pathable::Line.new([x, @last_point.last])
       end
 
     when 'V' # vertical lineto
       while values.any?
-        y = values.shift
+        y = values.shift.first
         y += @last_point.last if relative && @last_point
         push_command Prawn::SVG::Pathable::Line.new([@last_point.first, y])
       end
 
     when 'C' # curveto
       while values.any?
-        x1, y1, x2, y2, x, y = values.shift(6)
-        throw :invalid_command unless y
+        x1, y1, x2, y2, x, y = values.shift
 
         if relative && @last_point
           x += @last_point.first
@@ -112,8 +130,7 @@ class Prawn::SVG::Elements::Path < Prawn::SVG::Elements::Base
 
     when 'S' # shorthand/smooth curveto
       while values.any?
-        x2, y2, x, y = values.shift(4)
-        throw :invalid_command unless y
+        x2, y2, x, y = values.shift
 
         if relative && @last_point
           x += @last_point.first
@@ -136,13 +153,11 @@ class Prawn::SVG::Elements::Path < Prawn::SVG::Elements::Base
     when 'Q', 'T' # quadratic curveto
       while values.any?
         if shorthand = upcase_command == 'T'
-          x, y = values.shift(2)
+          x, y = values.shift
         else
-          x1, y1, x, y = values.shift(4)
+          x1, y1, x, y = values.shift
         end
 
-        throw :invalid_command unless y
-
         if relative && @last_point
           x += @last_point.first
           x1 += @last_point.first if x1
@@ -174,8 +189,7 @@ class Prawn::SVG::Elements::Path < Prawn::SVG::Elements::Base
       return unless @last_point
 
       while values.any?
-        rx, ry, phi, fa, fs, x2, y2 = values.shift(7)
-        throw :invalid_command unless y2
+        rx, ry, phi, fa, fs, x2, y2 = values.shift
 
         x1, y1 = @last_point
 
@@ -276,9 +290,8 @@ class Prawn::SVG::Elements::Path < Prawn::SVG::Elements::Base
   def match_all(string, regexp) # regexp must start with ^
     result = []
     while string != ""
-      matches = string.match(regexp)
-      result << matches
-      return if matches.nil?
+      matches = string.match(regexp) or return
+      result << matches.captures
       string = matches.post_match
     end
     result

data/lib/prawn/svg/elements/root.rb

@@ -8,7 +8,10 @@ class Prawn::SVG::Elements::Root < Prawn::SVG::Elements::Base
   end
 
   def apply
-    add_call 'fill_color', '000000'
+    if [nil, 'inherit', 'none', 'currentColor'].include?(properties.fill)
+      add_call 'fill_color', '000000'
+    end
+
     add_call 'transformation_matrix', @document.sizing.x_scale, 0, 0, @document.sizing.y_scale, 0, 0
     add_call 'transformation_matrix', 1, 0, 0, 1, -@document.sizing.x_offset, @document.sizing.y_offset
   end

data/lib/prawn/svg/elements/text_component.rb

@@ -2,7 +2,7 @@ class Prawn::SVG::Elements::TextComponent < Prawn::SVG::Elements::DepthFirstBase
   attr_reader :commands
 
   Printable = Struct.new(:element, :text, :leading_space?, :trailing_space?)
-  TextState = Struct.new(:parent, :x, :y, :dx, :dy, :rotation, :spacing, :mode)
+  TextState = Struct.new(:parent, :x, :y, :dx, :dy, :rotation, :spacing, :mode, :text_length, :length_adjust)
 
   def parse
     if state.inside_clip_path
@@ -14,6 +14,8 @@ class Prawn::SVG::Elements::TextComponent < Prawn::SVG::Elements::DepthFirstBase
     state.text.dx = (attributes['dx'] || "").split(COMMA_WSP_REGEXP).collect { |n| x_pixels(n) }
     state.text.dy = (attributes['dy'] || "").split(COMMA_WSP_REGEXP).collect { |n| y_pixels(n) }
     state.text.rotation = (attributes['rotate'] || "").split(COMMA_WSP_REGEXP).collect(&:to_f)
+    state.text.text_length = normalize_length(attributes['textLength'])
+    state.text.length_adjust = attributes['lengthAdjust']
     state.text.spacing = calculate_character_spacing
     state.text.mode = calculate_text_rendering_mode
 
@@ -44,9 +46,11 @@ class Prawn::SVG::Elements::TextComponent < Prawn::SVG::Elements::DepthFirstBase
     opts = {
       size:        computed_properties.numerical_font_size,
       style:       font && font.subfamily,
-      text_anchor: computed_properties.text_anchor
+      text_anchor: computed_properties.text_anchor,
     }
 
+    opts[:decoration] = computed_properties.text_decoration unless computed_properties.text_decoration == 'none'
+
     if state.text.parent
       add_call_and_enter 'character_spacing', state.text.spacing unless state.text.spacing == state.text.parent.spacing
       add_call_and_enter 'text_rendering_mode', state.text.mode unless state.text.mode == state.text.parent.mode
@@ -133,11 +137,19 @@ class Prawn::SVG::Elements::TextComponent < Prawn::SVG::Elements::DepthFirstBase
         opts.delete(:rotate)
       end
 
+      if state.text.text_length
+        if state.text.length_adjust == 'spacingAndGlyphs'
+          opts[:stretch_to_width] = state.text.text_length
+        else
+          opts[:pad_to_width] = state.text.text_length
+        end
+      end
+
       if remaining
-        add_call 'draw_text', text[0..0], opts.dup
+        add_call 'draw_text', text[0..0], **opts.dup
         text = text[1..-1]
       else
-        add_call 'draw_text', text, opts.dup
+        add_call 'draw_text', text, **opts.dup
 
         # we can get to this path with rotations still pending
         # solve this by shifting them out by the number of
@@ -173,7 +185,7 @@ class Prawn::SVG::Elements::TextComponent < Prawn::SVG::Elements::DepthFirstBase
   end
 
   def find_referenced_element
-    href = attributes['xlink:href']
+    href = href_attribute
 
     if href && href[0..0] == '#'
       element = document.elements_by_id[href[1..-1]]
@@ -222,4 +234,8 @@ class Prawn::SVG::Elements::TextComponent < Prawn::SVG::Elements::DepthFirstBase
   # overridden, we don't want to call fill/stroke as draw_text does this for us
   def apply_drawing_call
   end
+
+  def normalize_length(length)
+    x_pixels(length) if length && length.match(/\d/)
+  end
 end