prawn-svg 0.29.1 → 0.32.0

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

@@ -1,19 +1,35 @@
 class Prawn::SVG::Elements::Use < Prawn::SVG::Elements::Base
-  attr_reader :referenced_element
+  attr_reader :referenced_element_class
+  attr_reader :referenced_element_source
 
   def parse
-    require_attributes 'xlink:href'
-
-    href = attributes['xlink:href']
+    href = href_attribute
+    if href.nil?
+      raise SkipElementError, "use tag must have an href or xlink:href"
+    end
 
     if href[0..0] != '#'
       raise SkipElementError, "use tag has an href that is not a reference to an id; this is not supported"
     end
 
     id = href[1..-1]
-    @referenced_element = @document.elements_by_id[id]
+    referenced_element = @document.elements_by_id[id]
+
+    if referenced_element
+      @referenced_element_class = referenced_element.class
+      @referenced_element_source = referenced_element.source
+    else
+      # Perhaps the element is defined further down in the document.  This is not recommended but still valid SVG,
+      # so we'll support it with an exception case that's not particularly performant.
+      raw_element = REXML::XPath.match(@document.root, %(//*[@id="#{id.gsub('"', '\"')}"])).first
+
+      if raw_element
+        @referenced_element_class = Prawn::SVG::Elements::TAG_CLASS_MAPPING[raw_element.name.to_sym]
+        @referenced_element_source = raw_element
+      end
+    end
 
-    if referenced_element.nil?
+    if referenced_element_class.nil?
       raise SkipElementError, "no tag with ID '#{id}' was found, referenced by use tag"
     end
 
@@ -36,7 +52,7 @@ class Prawn::SVG::Elements::Use < Prawn::SVG::Elements::Base
   def process_child_elements
     add_call "save"
 
-    child = referenced_element.class.new(referenced_element.document, referenced_element.source, calls, state.dup)
+    child = referenced_element_class.new(document, referenced_element_source, calls, state.dup)
     child.process
 
     add_call "restore"

data/lib/prawn/svg/elements.rb

@@ -13,6 +13,7 @@ module Prawn::SVG::Elements
     g: Prawn::SVG::Elements::Container,
     symbol: Prawn::SVG::Elements::Container,
     defs: Prawn::SVG::Elements::Container,
+    a: Prawn::SVG::Elements::Container,
     clipPath: Prawn::SVG::Elements::ClipPath,
     switch: Prawn::SVG::Elements::Container,
     svg: Prawn::SVG::Elements::Viewport,
@@ -27,6 +28,7 @@ module Prawn::SVG::Elements
     use: Prawn::SVG::Elements::Use,
     image: Prawn::SVG::Elements::Image,
     linearGradient: Prawn::SVG::Elements::Gradient,
+    radialGradient: Prawn::SVG::Elements::Gradient,
     marker: Prawn::SVG::Elements::Marker,
     style: Prawn::SVG::Elements::Ignored, # because it is pre-parsed by Document
     title: Prawn::SVG::Elements::Ignored,

data/lib/prawn/svg/extensions/additional_gradient_transforms.rb

@@ -0,0 +1,23 @@
+module Prawn::SVG::Extensions
+  module AdditionalGradientTransforms
+    def gradient_coordinates(gradient)
+      # As of Prawn 2.2.0, apply_transformations is used as purely a boolean.
+      #
+      # Here we're using it to optionally pass in a 6-tuple transformation matrix that gets applied to the
+      # gradient.  This should be added to Prawn properly, and then this monkey patch will not be necessary.
+
+      if gradient.apply_transformations.is_a?(Array)
+        x1, y1, x2, y2, transformation = super
+        a, b, c, d, e, f = transformation
+        na, nb, nc, nd, ne, nf = gradient.apply_transformations
+
+        matrix = Matrix[[a, c, e], [b, d, f], [0, 0, 1]] * Matrix[[na, nc, ne], [nb, nd, nf], [0, 0, 1]]
+        new_transformation = matrix.to_a[0..1].transpose.flatten
+
+        [x1, y1, x2, y2, new_transformation]
+      else
+        super
+      end
+    end
+  end
+end

data/lib/prawn/svg/interface.rb

@@ -109,32 +109,40 @@ module Prawn
       end
 
       def issue_prawn_command(prawn, calls)
-        calls.each do |call, arguments, children|
+        calls.each do |call, arguments, kwarguments, children|
           skip = false
 
-          rewrite_call_arguments(prawn, call, arguments) do
+          rewrite_call_arguments(prawn, call, arguments, kwarguments) do
             issue_prawn_command(prawn, children) if children.any?
             skip = true
           end
 
           if skip
             # the call has been overridden
-          elsif children.empty?
-            prawn.send(call, *arguments)
+          elsif children.empty? && call != 'transparent' # some prawn calls complain if they aren't supplied a block
+            if RUBY_VERSION >= '2.7' || !kwarguments.empty?
+              prawn.send(call, *arguments, **kwarguments)
+            else
+              prawn.send(call, *arguments)
+            end
           else
-            prawn.send(call, *arguments, &proc_creator(prawn, children))
+            if RUBY_VERSION >= '2.7' || !kwarguments.empty?
+              prawn.send(call, *arguments, **kwarguments, &proc_creator(prawn, children))
+            else
+              prawn.send(call, *arguments, &proc_creator(prawn, children))
+            end
           end
         end
       end
 
-      def rewrite_call_arguments(prawn, call, arguments)
+      def rewrite_call_arguments(prawn, call, arguments, kwarguments)
         case call
         when 'text_group'
           @cursor = [0, document.sizing.output_height]
           yield
 
         when 'draw_text'
-          text, options = arguments
+          text, options = arguments.first, kwarguments
 
           at = options.fetch(:at)
 
@@ -148,6 +156,19 @@ module Prawn
 
           width = prawn.width_of(text, options.merge(kerning: true))
 
+          if stretch_to_width = options.delete(:stretch_to_width)
+            factor = stretch_to_width.to_f * 100 / width.to_f
+            prawn.add_content "#{factor} Tz"
+            width = stretch_to_width.to_f
+          end
+
+          if pad_to_width = options.delete(:pad_to_width)
+            padding_required = pad_to_width.to_f - width.to_f
+            padding_per_character = padding_required / text.length.to_f
+            prawn.add_content "#{padding_per_character} Tc"
+            width = pad_to_width.to_f
+          end
+
           case options.delete(:text_anchor)
           when 'middle'
             at[0] -= width / 2
@@ -159,6 +180,15 @@ module Prawn
             @cursor = [at[0] + width, at[1]]
           end
 
+          decoration = options.delete(:decoration)
+          if decoration == 'underline'
+            prawn.save_graphics_state do
+              prawn.line_width 1
+              prawn.line [at[0], at[1] - 1.25], [at[0] + width, at[1] - 1.25]
+              prawn.stroke
+            end
+          end
+
         when 'transformation_matrix'
           left = prawn.bounds.absolute_left
           top = prawn.bounds.absolute_top
@@ -186,7 +216,7 @@ module Prawn
           # prawn (as at 2.0.1 anyway) uses 'b' for its fill_and_stroke.  'b' is 'h' (closepath) + 'B', and we
           # never want closepath to be automatically run as it stuffs up many drawing operations, such as dashes
           # and line caps, and makes paths close that we didn't ask to be closed when fill is specified.
-          even_odd = arguments[0].is_a?(Hash) && arguments[0][:fill_rule] == :even_odd
+          even_odd = kwarguments[:fill_rule] == :even_odd
           content  = even_odd ? 'B*' : 'B'
           prawn.add_content content
 

data/lib/prawn/svg/loaders/data.rb

@@ -2,7 +2,7 @@ require 'base64'
 
 module Prawn::SVG::Loaders
   class Data
-    REGEXP = %r[\A(?i:data):image/(png|jpeg);base64(;[a-z0-9]+)*,]
+    REGEXP = %r[\Adata:image/(png|jpeg);base64(;[a-z0-9]+)*,]i
 
     def from_url(url)
       return if url[0..4].downcase != "data:"

data/lib/prawn/svg/loaders/file.rb

@@ -1,3 +1,5 @@
+require 'addressable/uri'
+
 #
 # Load a file from disk.
 #
@@ -56,7 +58,7 @@ module Prawn::SVG::Loaders
     private
 
     def load_file(path)
-      path = URI.decode(path)
+      path = Addressable::URI.unencode(path)
       path = build_absolute_and_expand_path(path)
       assert_valid_path!(path)
       assert_file_exists!(path)

data/lib/prawn/svg/properties.rb

@@ -37,6 +37,7 @@ class Prawn::SVG::Properties
     "stroke-opacity"   => Config.new("1", true),
     "stroke-width"     => Config.new("1", true),
     "text-anchor"      => Config.new("start", true, %w(inherit start middle end), true),
+    'text-decoration'  => Config.new('none', true, %w(inherit none underline), true),
   }.freeze
 
   PROPERTIES.each do |name, value|

data/lib/prawn/svg/transform_parser.rb

@@ -0,0 +1,72 @@
+module Prawn::SVG::TransformParser
+  def parse_transform_attribute(transform)
+    matrix = Matrix.identity(3)
+
+    parse_css_method_calls(transform).each do |name, arguments|
+      case name
+      when 'translate'
+        x, y = arguments
+        matrix *= Matrix[[1, 0, x_pixels(x.to_f)], [0, 1, -y_pixels(y.to_f)], [0, 0, 1]]
+
+      when 'translateX'
+        x = arguments.first
+        matrix *= Matrix[[1, 0, x_pixels(x.to_f)], [0, 1, 0], [0, 0, 1]]
+
+      when 'translateY'
+        y = arguments.first
+        matrix *= Matrix[[1, 0, 0], [0, 1, -y_pixels(y.to_f)], [0, 0, 1]]
+
+      when 'rotate'
+        angle, x, y = arguments.collect { |a| a.to_f }
+        angle = angle * Math::PI / 180.0
+
+        case arguments.length
+        when 1
+          matrix *= Matrix[[Math.cos(angle), Math.sin(angle), 0], [-Math.sin(angle), Math.cos(angle), 0], [0, 0, 1]]
+        when 3
+          matrix *= Matrix[[1, 0, x_pixels(x.to_f)], [0, 1, -y_pixels(y.to_f)], [0, 0, 1]]
+          matrix *= Matrix[[Math.cos(angle), Math.sin(angle), 0], [-Math.sin(angle), Math.cos(angle), 0], [0, 0, 1]]
+          matrix *= Matrix[[1, 0, -x_pixels(x.to_f)], [0, 1, y_pixels(y.to_f)], [0, 0, 1]]
+        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
+        matrix *= Matrix[[x_scale, 0, 0], [0, y_scale, 0], [0, 0, 1]]
+
+      when 'skewX'
+        angle = arguments[0].to_f * Math::PI / 180.0
+        matrix *= Matrix[[1, -Math.tan(angle), 0], [0, 1, 0], [0, 0, 1]]
+
+      when 'skewY'
+        angle = arguments[0].to_f * Math::PI / 180.0
+        matrix *= Matrix[[1, 0, 0], [-Math.tan(angle), 1, 0], [0, 0, 1]]
+
+      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 }
+          matrix *= Matrix[[a, -c, e], [-b, d, -f], [0, 0, 1]]
+        end
+
+      else
+        warnings << "Unknown/unsupported transformation '#{name}'; ignoring"
+      end
+    end
+
+    matrix.to_a[0..1].transpose.flatten
+  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
+  end
+end

data/lib/prawn/svg/version.rb

@@ -1,5 +1,5 @@
 module Prawn
   module SVG
-    VERSION = '0.29.1'
+    VERSION = '0.32.0'
   end
 end

data/lib/prawn-svg.rb

@@ -10,6 +10,7 @@ require 'prawn/svg/calculators/arc_to_bezier_curve'
 require 'prawn/svg/calculators/aspect_ratio'
 require 'prawn/svg/calculators/document_sizing'
 require 'prawn/svg/calculators/pixels'
+require 'prawn/svg/transform_parser'
 require 'prawn/svg/url_loader'
 require 'prawn/svg/loaders/data'
 require 'prawn/svg/loaders/file'
@@ -29,6 +30,9 @@ require 'prawn/svg/font'
 require 'prawn/svg/document'
 require 'prawn/svg/state'
 
+require 'prawn/svg/extensions/additional_gradient_transforms'
+Prawn::Document.prepend Prawn::SVG::Extensions::AdditionalGradientTransforms
+
 module Prawn
   Svg = SVG # backwards compatibility
 end

data/prawn-svg.gemspec

@@ -17,10 +17,11 @@ Gem::Specification.new do |gem|
   gem.name          = "prawn-svg"
   gem.require_paths = ["lib"]
 
-  gem.required_ruby_version = '>= 2.1.0'
+  gem.required_ruby_version = '>= 2.3.0'
 
   gem.add_runtime_dependency "prawn", ">= 0.11.1", "< 3"
   gem.add_runtime_dependency "css_parser", "~> 1.6"
+  gem.add_runtime_dependency "rexml", "~> 3.2"
   gem.add_development_dependency "rspec", "~> 3.0"
-  gem.add_development_dependency "rake", "~> 10.1"
+  gem.add_development_dependency "rake", "~> 13.0"
 end

data/spec/integration_spec.rb

@@ -28,34 +28,34 @@ describe "Integration test" do
       element.process
 
       expect(element.calls).to eq [
-        ["fill_color", ["000000"], []],
-        ["transformation_matrix", [1, 0, 0, 1, 0, 0], []],
-        ["transformation_matrix", [1, 0, 0, 1, 0, 0], []],
-        ["save", [], []], ["restore", [], []],
-        ["save", [], []],
-        ["fill_color", ["0000ff"], []],
-        ["fill", [], [
-          ["rectangle", [[0.0, 200.0], 10.0, 10.0], []]
+        ["fill_color", ["000000"], {}, []],
+        ["transformation_matrix", [1, 0, 0, 1, 0, 0], {}, []],
+        ["transformation_matrix", [1, 0, 0, 1, 0, 0], {}, []],
+        ["save", [], {}, []], ["restore", [], {}, []],
+        ["save", [], {}, []],
+        ["fill_color", ["0000ff"], {}, []],
+        ["fill", [], {}, [
+          ["rectangle", [[0.0, 200.0], 10.0, 10.0], {}, []]
         ]],
-        ["restore", [], []],
-        ["save", [], []],
-        ["fill_color", ["008000"], []],
-        ["fill", [], [
-          ["rectangle", [[10.0, 200.0], 10.0, 10.0], []]
+        ["restore", [], {}, []],
+        ["save", [], {}, []],
+        ["fill_color", ["008000"], {}, []],
+        ["fill", [], {}, [
+          ["rectangle", [[10.0, 200.0], 10.0, 10.0], {}, []]
         ]],
-        ["restore", [], []],
-        ["save", [], []],
-        ["fill_color", ["ff0000"], []],
-        ["fill", [], [
-          ["rectangle", [[20.0, 200.0], 10.0, 10.0], []]
+        ["restore", [], {}, []],
+        ["save", [], {}, []],
+        ["fill_color", ["ff0000"], {}, []],
+        ["fill", [], {}, [
+          ["rectangle", [[20.0, 200.0], 10.0, 10.0], {}, []]
         ]],
-        ["restore", [], []],
-        ["save", [], []],
-        ["fill_color", ["ffff00"], []],
-        ["fill", [], [
-          ["rectangle", [[30.0, 200.0], 10.0, 10.0], []]
+        ["restore", [], {}, []],
+        ["save", [], {}, []],
+        ["fill_color", ["ffff00"], {}, []],
+        ["fill", [], {}, [
+          ["rectangle", [[30.0, 200.0], 10.0, 10.0], {}, []]
         ]],
-        ["restore", [], []]
+        ["restore", [], {}, []]
       ]
     end
   end

data/spec/prawn/svg/attributes/opacity_spec.rb

@@ -0,0 +1,85 @@
+require 'spec_helper'
+
+describe Prawn::SVG::Attributes::Opacity do
+  class OpacityTestElement
+    include Prawn::SVG::Attributes::Opacity
+
+    attr_accessor :properties, :state
+
+    def initialize
+      @properties = ::Prawn::SVG::Properties.new
+      @state = ::Prawn::SVG::State.new
+    end
+
+    def clamp(value, min_value, max_value)
+      [[value, min_value].max, max_value].min
+    end
+  end
+
+  let(:element) { OpacityTestElement.new }
+
+  describe "#parse_opacity_attributes_and_call" do
+    subject { element.parse_opacity_attributes_and_call }
+
+    context "with no opacity specified" do
+      it "does nothing" do
+        expect(element).not_to receive(:add_call_and_enter)
+        subject
+      end
+    end
+
+    context "with opacity" do
+      it "sets fill and stroke opacity" do
+        element.properties.opacity = '0.4'
+
+        expect(element).to receive(:add_call_and_enter).with('transparent', 0.4, 0.4)
+        subject
+
+        expect(element.state.fill_opacity).to eq 0.4
+        expect(element.state.stroke_opacity).to eq 0.4
+      end
+    end
+
+    context "with just fill opacity" do
+      it "sets fill opacity and sets stroke opacity to 1" do
+        element.properties.fill_opacity = '0.4'
+
+        expect(element).to receive(:add_call_and_enter).with('transparent', 0.4, 1)
+        subject
+
+        expect(element.state.fill_opacity).to eq 0.4
+        expect(element.state.stroke_opacity).to eq 1
+      end
+    end
+
+    context "with an existing fill/stroke opacity" do
+      it "multiplies the new opacity by the old" do
+        element.state.fill_opacity = 0.5
+        element.state.stroke_opacity = 0.8
+
+        element.properties.fill_opacity = '0.4'
+        element.properties.stroke_opacity = '0.5'
+
+        expect(element).to receive(:add_call_and_enter).with('transparent', 0.2, 0.4)
+        subject
+
+        expect(element.state.fill_opacity).to eq 0.2
+        expect(element.state.stroke_opacity).to eq 0.4
+      end
+    end
+
+    context "with stroke, fill, and opacity all specified" do
+      it "choses the lower of them" do
+        element.properties.fill_opacity = '0.4'
+        element.properties.stroke_opacity = '0.6'
+        element.properties.opacity = '0.5'
+
+        expect(element).to receive(:add_call_and_enter).with('transparent', 0.4, 0.5)
+        subject
+
+        expect(element.state.fill_opacity).to eq 0.4
+        expect(element.state.stroke_opacity).to eq 0.5
+      end
+    end
+  end
+end

data/spec/prawn/svg/attributes/transform_spec.rb

@@ -14,43 +14,38 @@ describe Prawn::SVG::Attributes::Transform do
 
   let(:element) { TransformTestElement.new }
 
-  describe "#parse_transform_attribute_and_call" do
-    subject { element.send :parse_transform_attribute_and_call }
-
-    describe "translate" do
-      it "handles a missing y argument" do
-        expect(element).to receive(:add_call_and_enter).with('translate', -5.5, 0)
-        expect(element).to receive(:x_pixels).with(-5.5).and_return(-5.5)
-        expect(element).to receive(:y_pixels).with(0.0).and_return(0.0)
-
-        element.attributes['transform'] = 'translate(-5.5)'
-        subject
-      end
+  subject { element.send :parse_transform_attribute_and_call }
+
+  context "when a non-identity matrix is requested" do
+    let(:transform) { 'translate(-5.5)' }
+
+    it "passes the transform and executes the returned matrix" do
+      expect(element).to receive(:parse_transform_attribute).with(transform).and_return([1, 2, 3, 4, 5, 6])
+      expect(element).to receive(:add_call_and_enter).with('transformation_matrix', 1, 2, 3, 4, 5, 6)
+
+      element.attributes['transform'] = transform
+      subject
+    end
+  end
+
+  context "when an identity matrix is requested" do
+    let(:transform) { 'translate(0)' }
+
+    it "does not execute any commands" do
+      expect(element).to receive(:parse_transform_attribute).with(transform).and_return([1, 0, 0, 1, 0, 0])
+      expect(element).not_to receive(:add_call_and_enter)
+
+      element.attributes['transform'] = transform
+      subject
     end
+  end
+
+  context "when transform is blank" do
+    it "does nothing" do
+      expect(element).not_to receive(:parse_transform_attribute)
+      expect(element).not_to receive(:add_call_and_enter)
 
-    describe "rotate" do
-      it "handles a single angle argument" do
-        expect(element).to receive(:add_call_and_enter).with('rotate', -5.5, :origin => [0, 0])
-        expect(element).to receive(:y).with('0').and_return(0)
-
-        element.attributes['transform'] = 'rotate(5.5)'
-        subject
-      end
-
-      it "handles three arguments" do
-        expect(element).to receive(:add_call_and_enter).with('rotate', -5.5, :origin => [1.0, 2.0])
-        expect(element).to receive(:x).with(1.0).and_return(1.0)
-        expect(element).to receive(:y).with(2.0).and_return(2.0)
-
-        element.attributes['transform'] = 'rotate(5.5 1 2)'
-        subject
-      end
-
-      it "does nothing and warns if two arguments" do
-        expect(element).to receive(:warnings).and_return([])
-        element.attributes['transform'] = 'rotate(5.5 1)'
-        subject
-      end
+      subject
     end
   end
 end

data/spec/prawn/svg/css/stylesheets_spec.rb

@@ -68,25 +68,7 @@ RSpec.describe Prawn::SVG::CSS::Stylesheets do
         [4, [["fill", "#ff0000", false], ["fill", "#330000", false], ["fill", "#440000", false], ["fill", "#00ff00", false]]],
       ]
 
-      #
-      # Under ruby < 2.6, a bug in REXML causes the /following-sibling selector to
-      # only pick the first matching sibling.  This means the + CSS combinator behaves
-      # incorrectly in the following example:
-      #
-      # <a>
-      #   <b a="1" />
-      #   <b a="2" />
-      #   <b a="3" />
-      # </a>
-      #
-      # The css selector `a b + b` will only pick the second <b>, whereas it should
-      # pick both the second and third <b> elements.
-      #
-      if Gem::Version.new(RUBY_VERSION) < Gem::Version.new('2.6.0')
-        expected << [5, [["fill", "#ff0000", false], ["fill", "#330000", false], ["fill", "#330000", false], ["fill", "#00ff00", false]]]
-      else
-        expected << [5, [["fill", "#ff0000", false], ["fill", "#330000", false], ["fill", "#330000", false], ["fill", "#440000", false], ["fill", "#00ff00", false]]]
-      end
+      expected << [5, [["fill", "#ff0000", false], ["fill", "#330000", false], ["fill", "#330000", false], ["fill", "#440000", false], ["fill", "#00ff00", false]]]
 
       expected.concat [
         [6, [["fill", "#ff0000", false], ["fill", "#441234", false], ["fill", "#0000ff", false]]],

data/spec/prawn/svg/elements/base_spec.rb

@@ -25,19 +25,19 @@ describe Prawn::SVG::Elements::Base do
     describe "applying calls from the standard attributes" do
       let(:svg) do
         <<-SVG
-          <something transform="rotate(90)" fill-opacity="0.5" fill="red" stroke="blue" stroke-width="5"/>
+          <something transform="scale(2)" fill-opacity="0.5" fill="red" stroke="blue" stroke-width="5"/>
         SVG
       end
 
       it "appends the relevant calls" do
         element.process
         expect(element.base_calls).to eq [
-          ["rotate", [-90.0, {origin: [0, 600.0]}], [
-            ["transparent", [0.5, 1], [
-              ["fill_color", ["ff0000"], []],
-              ["stroke_color", ["0000ff"], []],
-              ["line_width", [5.0], []],
-              ["fill_and_stroke", [], []]
+          ["transformation_matrix", [2, 0, 0, 2, 0, 0], {}, [
+            ["transparent", [0.5, 1], {}, [
+              ["fill_color", ["ff0000"], {}, []],
+              ["stroke_color", ["0000ff"], {}, []],
+              ["line_width", [5.0], {}, []],
+              ["fill_and_stroke", [], {}, []]
             ]]
           ]]
         ]
@@ -50,37 +50,37 @@ describe Prawn::SVG::Elements::Base do
 
       context "with neither fill nor stroke" do
         let(:svg) { '<rect style="fill: none;"></rect>' }
-        it        { is_expected.to eq ['end_path', [], []] }
+        it        { is_expected.to eq ['end_path', [], {}, []] }
       end
 
       context "with a fill only" do
         let(:svg) { '<rect style="fill: black;"></rect>' }
-        it        { is_expected.to eq ['fill', [], []] }
+        it        { is_expected.to eq ['fill', [], {}, []] }
       end
 
       context "with a stroke only" do
         let(:svg) { '<rect style="fill: none; stroke: black;"></rect>' }
-        it        { is_expected.to eq ['stroke', [], []] }
+        it        { is_expected.to eq ['stroke', [], {}, []] }
       end
 
       context "with fill and stroke" do
         let(:svg) { '<rect style="fill: black; stroke: black;"></rect>' }
-        it        { is_expected.to eq ['fill_and_stroke', [], []] }
+        it        { is_expected.to eq ['fill_and_stroke', [], {}, []] }
       end
 
       context "with fill with evenodd fill rule" do
         let(:svg) { '<rect style="fill: black; fill-rule: evenodd;"></rect>' }
-        it        { is_expected.to eq ['fill', [{fill_rule: :even_odd}], []] }
+        it        { is_expected.to eq ['fill', [], {fill_rule: :even_odd}, []] }
       end
     end
 
     it "appends calls to the parent element" do
       expect(element).to receive(:apply) do
-        element.send :add_call, "test", "argument"
+        element.send :add_call, "test", "argument", kw: 'argument'
       end
 
       element.process
-      expect(element.parent_calls).to eq [["fill", [], [["test", ["argument"], []]]]]
+      expect(element.parent_calls).to eq [["fill", [], {}, [["test", ["argument"], {kw: 'argument'}, []]]]]
     end
 
     it "quietly absorbs a SkipElementQuietly exception" do
@@ -149,8 +149,8 @@ describe Prawn::SVG::Elements::Base do
       it "uses the parent's color element if 'currentColor' fill attribute provided" do
         element.process
 
-        expect(flattened_calls).to include ['fill_color', ['ff0000']]
-        expect(flattened_calls).not_to include ['fill_color', ['00ff00']]
+        expect(flattened_calls).to include ['fill_color', ['ff0000'], {}]
+        expect(flattened_calls).not_to include ['fill_color', ['00ff00'], {}]
       end
     end