prawn-svg 0.35.0 → 0.36.0

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

@@ -10,6 +10,10 @@ describe Prawn::SVG::Attributes::Opacity do
       @properties = ::Prawn::SVG::Properties.new
       @state = ::Prawn::SVG::State.new
     end
+
+    def computed_properties
+      @state.computed_properties
+    end
   end
 
   let(:element) { OpacityTestElement.new }
@@ -26,55 +30,58 @@ describe Prawn::SVG::Attributes::Opacity do
 
     context 'with opacity' do
       it 'sets fill and stroke opacity' do
-        element.properties.opacity = '0.4'
+        element.computed_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
+        expect(element.state.opacity).to eq 0.4
+        expect(element.state.last_fill_opacity).to eq 0.4
+        expect(element.state.last_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'
+        element.computed_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
+        expect(element.state.opacity).to eq 1
+        expect(element.state.last_fill_opacity).to eq 0.4
+        expect(element.state.last_stroke_opacity).to eq 1
       end
     end
 
-    context 'with an existing fill/stroke opacity' do
+    context 'with an existing 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.state.opacity = 0.5
 
-        element.properties.fill_opacity = '0.4'
-        element.properties.stroke_opacity = '0.5'
+        element.computed_properties.fill_opacity = '0.4'
+        element.computed_properties.stroke_opacity = '0.5'
 
-        expect(element).to receive(:add_call_and_enter).with('transparent', 0.2, 0.4)
+        expect(element).to receive(:add_call_and_enter).with('transparent', 0.2, 0.25)
         subject
 
-        expect(element.state.fill_opacity).to eq 0.2
-        expect(element.state.stroke_opacity).to eq 0.4
+        expect(element.state.opacity).to eq 0.5
+        expect(element.state.last_fill_opacity).to eq 0.2
+        expect(element.state.last_stroke_opacity).to eq 0.25
       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'
+        element.computed_properties.fill_opacity = '0.4'
+        element.computed_properties.stroke_opacity = '0.6'
+        element.computed_properties.opacity = '0.5'
 
-        expect(element).to receive(:add_call_and_enter).with('transparent', 0.4, 0.5)
+        expect(element).to receive(:add_call_and_enter).with('transparent', 0.2, 0.3)
         subject
 
-        expect(element.state.fill_opacity).to eq 0.4
-        expect(element.state.stroke_opacity).to eq 0.5
+        expect(element.state.opacity).to eq 0.5
+        expect(element.state.last_fill_opacity).to eq 0.2
+        expect(element.state.last_stroke_opacity).to eq 0.3
       end
     end
   end

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

@@ -20,7 +20,8 @@ describe Prawn::SVG::Attributes::Transform 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(:parse_transform_attribute).with(transform)
+      expect(element).to receive(:matrix_for_pdf).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
@@ -32,7 +33,8 @@ describe Prawn::SVG::Attributes::Transform 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).to receive(:parse_transform_attribute).with(transform)
+      expect(element).to receive(:matrix_for_pdf).and_return([1, 0, 0, 1, 0, 0])
       expect(element).not_to receive(:add_call_and_enter)
 
       element.attributes['transform'] = transform
@@ -43,6 +45,7 @@ describe Prawn::SVG::Attributes::Transform do
   context 'when transform is blank' do
     it 'does nothing' do
       expect(element).not_to receive(:parse_transform_attribute)
+      expect(element).not_to receive(:matrix_for_pdf)
       expect(element).not_to receive(:add_call_and_enter)
 
       subject

data/spec/prawn/svg/calculators/pixels_spec.rb

@@ -5,7 +5,7 @@ describe Prawn::SVG::Calculators::Pixels do
     include Prawn::SVG::Calculators::Pixels
 
     def computed_properties
-      Struct.new(:numerical_font_size).new(16)
+      Struct.new(:numeric_font_size).new(16)
     end
 
     [:x, :y, :pixels, :x_pixels, :y_pixels].each { |method| public method }
@@ -35,7 +35,6 @@ describe Prawn::SVG::Calculators::Pixels do
       expect(subject.pixels(32)).to eq 32.0
       expect(subject.pixels(32.0)).to eq 32.0
       expect(subject.pixels('32')).to eq 32.0
-      expect(subject.pixels('32unknown')).to eq 32.0
       expect(subject.pixels('32px')).to eq 32.0
       expect(subject.pixels('32pt')).to eq 32.0
       expect(subject.pixels('32in')).to eq 32.0 * 72

data/spec/prawn/svg/color_spec.rb

@@ -1,74 +1,44 @@
 require "#{File.dirname(__FILE__)}/../../spec_helper"
 
 describe Prawn::SVG::Color do
-  describe '::css_color_to_prawn_color' do
-    it 'converts #xxx to a hex value' do
-      Prawn::SVG::Color.css_color_to_prawn_color('#9ab').should == '99aabb'
-    end
-
-    it 'converts #xxxxxx to a hex value' do
-      Prawn::SVG::Color.css_color_to_prawn_color('#9ab123').should == '9ab123'
-    end
-
-    it 'converts an html colour name to a hex value' do
-      Prawn::SVG::Color.css_color_to_prawn_color('White').should == 'ffffff'
-    end
-
-    it 'converts an rgb string to a hex value' do
-      Prawn::SVG::Color.css_color_to_prawn_color('rgb(16, 32, 48)').should
-      Prawn::SVG::Color.css_color_to_prawn_color('rgb(-5, 50%, 120%)').should == '007fff'
+  describe '::parse' do
+    def parse(value)
+      values = Prawn::SVG::CSS::ValuesParser.parse(value)
+      Prawn::SVG::Color.parse(values[0])
     end
 
-    it 'converts a CMYK string to an array of numbers' do
-      expect(Prawn::SVG::Color.css_color_to_prawn_color('device-cmyk(0, 0.32, 0.48, 1)')).to eq [0, 32, 48, 100]
-      expect(Prawn::SVG::Color.css_color_to_prawn_color('device-cmyk(-5, 50%, 120%, -5%)')).to eq [0, 50, 100, 0]
+    it 'converts #xxx to an RGB color' do
+      expect(parse('#9ab')).to eq Prawn::SVG::Color::RGB.new('99aabb')
     end
 
-    it 'scans the string and finds the first colour it can parse' do
-      Prawn::SVG::Color.css_color_to_prawn_color('function(#someurl, 0) nonexistent rgb( 3 ,4,5 ) white').should == '030405'
+    it 'converts #xxxxxx to an RGB color' do
+      expect(parse('#9ab123')).to eq Prawn::SVG::Color::RGB.new('9ab123')
     end
 
-    it 'ignores url()s' do
-      expect(Prawn::SVG::Color.css_color_to_prawn_color('url(#someplace) red')).to eq 'ff0000'
+    it 'converts an html colour name to an RGB color' do
+      expect(parse('White')).to eq Prawn::SVG::Color::RGB.new('ffffff')
     end
 
-    it "returns black if the color doesn't exist" do
-      expect(Prawn::SVG::Color.css_color_to_prawn_color('blurble')).to eq '000000'
+    it 'converts an rgb function to an RGB color' do
+      expect(parse('rgb(16, 32, 48)')).to eq Prawn::SVG::Color::RGB.new('102030')
+      expect(parse('rgb(-5, 50%, 120%)')).to eq Prawn::SVG::Color::RGB.new('007fff')
     end
 
-    it "returns nil if there's no fallback after a url()" do
-      expect(Prawn::SVG::Color.css_color_to_prawn_color('url(#someplace)')).to be nil
+    it 'converts a CMYK string to an array of numbers' do
+      expect(parse('device-cmyk(0, 0.32, 0.48, 1.2)')).to eq Prawn::SVG::Color::CMYK.new([0, 32, 48, 100])
+      expect(parse('device-cmyk(0, 50%, 120%, -5%)')).to eq Prawn::SVG::Color::CMYK.new([0, 50, 100, 0])
     end
-  end
-
-  describe '::parse' do
-    let(:gradients) { { 'flan' => flan_gradient, 'drob' => drob_gradient } }
-    let(:flan_gradient) { double }
-    let(:drob_gradient) { double }
 
-    it 'returns a list of all colors parsed, ignoring impossible or non-existent colors' do
-      results = Prawn::SVG::Color.parse('url(#nope) url(#flan) blurble green #123', gradients, :rgb)
-      expect(results).to eq [
-        flan_gradient,
-        Prawn::SVG::Color::RGB.new('008000'),
-        Prawn::SVG::Color::RGB.new('112233')
-      ]
+    it "returns nil if the color doesn't exist" do
+      expect(parse('blurble')).to be nil
     end
 
-    it "appends black to the list if there aren't any url() references" do
-      results = Prawn::SVG::Color.parse('blurble green', gradients, :rgb)
-      expect(results).to eq [
-        Prawn::SVG::Color::RGB.new('008000'),
-        Prawn::SVG::Color::RGB.new('000000')
-      ]
+    it 'returns nil if the function has the wrong number of arguments' do
+      expect(parse('rgb(-1, 0)')).to be nil
     end
 
-    it 'works in CMYK color mode' do
-      results = Prawn::SVG::Color.parse('blurble green', gradients, :cmyk)
-      expect(results).to eq [
-        Prawn::SVG::Color::CMYK.new([100, 0, 100, 50]),
-        Prawn::SVG::Color::CMYK.new([0, 0, 0, 100])
-      ]
+    it "returns nil if it doesn't recognise the function" do
+      expect(parse('hsl(0, 0, 0)')).to be nil
     end
   end
 end

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

@@ -120,27 +120,27 @@ describe Prawn::SVG::Elements::Base do
     end
 
     it "doesn't change anything if 'none' fill attribute provided" do
-      element.properties.fill = 'none'
+      element.properties.fill = Prawn::SVG::Paint.parse('none')
       expect(element).to_not receive(:add_call)
       subject
     end
 
     it "uses the fill attribute's color" do
       expect(element).to receive(:add_call).with('fill_color', 'ff0000')
-      element.properties.fill = 'red'
+      element.properties.fill = Prawn::SVG::Paint.parse('red')
       subject
     end
 
-    it "uses black if the fill attribute's color is unparseable" do
-      expect(element).to receive(:add_call).with('fill_color', '000000')
-      element.properties.fill = 'blarble'
+    it "ignores the instruction if the fill attribute's color is unparseable" do
+      element.properties.fill = Prawn::SVG::Paint.parse('blarble')
+      expect(element).to_not receive(:add_call)
       subject
     end
 
     it "uses the color attribute if 'currentColor' fill attribute provided" do
+      element.properties.fill = Prawn::SVG::Paint.parse('currentColor')
+      element.state.computed_properties.color = Prawn::SVG::Color::RGB.new('ff0000')
       expect(element).to receive(:add_call).with('fill_color', 'ff0000')
-      element.properties.fill = 'currentColor'
-      element.state.computed_properties.color = 'red'
       subject
     end
 
@@ -159,11 +159,10 @@ describe Prawn::SVG::Elements::Base do
       end
     end
 
-    it "computes to 'none' if UnresolvableURLWithNoFallbackError is raised" do
+    it 'specifies no color if the URL is unresolvable' do
       expect(element).to_not receive(:add_call)
-      element.properties.fill = 'url()'
+      element.properties.fill = Prawn::SVG::Paint.parse('url(bad)')
       subject
-      expect(element.computed_properties.fill).to eq 'none'
     end
   end
 

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

@@ -2,11 +2,11 @@ require 'spec_helper'
 
 describe Prawn::SVG::Elements::Gradient do
   let(:document) { Prawn::SVG::Document.new(svg, [800, 600], { width: 800, height: 600 }) }
-  let(:element)  { Prawn::SVG::Elements::Gradient.new(document, document.root, [], fake_state) }
+  let(:root_element) { Prawn::SVG::Elements::Root.new(document, document.root, []) }
+  let(:element) { document.gradients['flag'] }
 
   before do
-    allow(element).to receive(:assert_compatible_prawn_version)
-    element.process
+    root_element.process
   end
 
   describe 'object bounding box with linear gradient' do
@@ -27,17 +27,20 @@ describe Prawn::SVG::Elements::Gradient do
     it 'returns correct gradient arguments for an element' do
       arguments = element.gradient_arguments(double(bounding_box: [100, 100, 200, 0]))
       expect(arguments).to eq(
-        from:                  [100.0, 100.0],
-        to:                    [120.0, 0.0],
-        stops:                 [[0, 'ff0000'], [0.25, 'ff0000'], [0.5, 'ffffff'], [0.75, '0000ff'], [1, '0000ff']],
-        apply_transformations: true
+        from:         [0.0, 0.0],
+        to:           [0.2, 1.0],
+        wrap:         :pad,
+        matrix:       Matrix[[100.0, 0.0, 100.0], [0.0, -100.0, 100.0], [0.0, 0.0, 1.0]],
+        bounding_box: [100, 100, 200, 0],
+        stops:        [
+          { offset: 0, color: 'ff0000', opacity: 1.0 },
+          { offset: 0.25, color: 'ff0000', opacity: 1.0 },
+          { offset: 0.5, color: 'ffffff', opacity: 1.0 },
+          { offset: 0.75, color: '0000ff', opacity: 1.0 },
+          { offset: 1, color: '0000ff', opacity: 1.0 }
+        ]
       )
     end
-
-    it "returns nil if the element doesn't have a bounding box" do
-      arguments = element.gradient_arguments(double(bounding_box: nil))
-      expect(arguments).to be nil
-    end
   end
 
   describe 'object bounding box with radial gradient' do
@@ -58,12 +61,20 @@ describe Prawn::SVG::Elements::Gradient do
     it 'returns correct gradient arguments for an element' do
       arguments = element.gradient_arguments(double(bounding_box: [100, 100, 200, 0]))
       expect(arguments).to eq(
-        from:                  [150, 80],
-        to:                    [100, 80],
-        r1:                    0,
-        r2:                    Math.sqrt(((0.8 * 100)**2) + ((0.8 * 100)**2)),
-        stops:                 [[0, 'ff0000'], [0.25, 'ff0000'], [0.5, 'ffffff'], [0.75, '0000ff'], [1, '0000ff']],
-        apply_transformations: true
+        from:         [0.5, 0.2],
+        to:           [0.0, 0.2],
+        r1:           0,
+        r2:           0.8,
+        wrap:         :pad,
+        matrix:       Matrix[[100.0, 0.0, 100.0], [0.0, -100.0, 100.0], [0.0, 0.0, 1.0]],
+        bounding_box: [100, 100, 200, 0],
+        stops:        [
+          { offset: 0, color: 'ff0000', opacity: 1.0 },
+          { offset: 0.25, color: 'ff0000', opacity: 1.0 },
+          { offset: 0.5, color: 'ffffff', opacity: 1.0 },
+          { offset: 0.75, color: '0000ff', opacity: 1.0 },
+          { offset: 1, color: '0000ff', opacity: 1.0 }
+        ]
       )
     end
   end
@@ -79,12 +90,14 @@ describe Prawn::SVG::Elements::Gradient do
     end
 
     it 'returns correct gradient arguments for an element' do
-      arguments = element.gradient_arguments(double)
+      arguments = element.gradient_arguments(double(bounding_box: [100, 100, 200, 0]))
       expect(arguments).to eq(
-        from:                  [100.0, 100.0],
-        to:                    [200.0, 0.0],
-        stops:                 [[0, 'ff0000'], [1, '0000ff']],
-        apply_transformations: true
+        from:         [100.0, 500.0],
+        to:           [200.0, 600.0],
+        stops:        [{ offset: 0, color: 'ff0000', opacity: 1.0 }, { offset: 1, color: '0000ff', opacity: 1.0 }],
+        matrix:       Matrix[[1.0, 0.0, 0.0], [0.0, -1.0, 600.0], [0.0, 0.0, 1.0]],
+        wrap:         :pad,
+        bounding_box: [100, 100, 200, 0]
       )
     end
   end
@@ -100,14 +113,16 @@ describe Prawn::SVG::Elements::Gradient do
     end
 
     it 'returns correct gradient arguments for an element' do
-      arguments = element.gradient_arguments(double)
+      arguments = element.gradient_arguments(double(bounding_box: [100, 100, 200, 0]))
       expect(arguments).to eq(
-        from:                  [100.0, 100.0],
-        to:                    [200.0, 0.0],
-        r1:                    0,
-        r2:                    150,
-        stops:                 [[0, 'ff0000'], [1, '0000ff']],
-        apply_transformations: true
+        from:         [100.0, 500.0],
+        to:           [200.0, 600.0],
+        r1:           0,
+        r2:           150.0,
+        stops:        [{ offset: 0, color: 'ff0000', opacity: 1.0 }, { offset: 1, color: '0000ff', opacity: 1.0 }],
+        matrix:       Matrix[[1.0, 0.0, 0.0], [0.0, -1.0, 600.0], [0.0, 0.0, 1.0]],
+        wrap:         :pad,
+        bounding_box: [100, 100, 200, 0]
       )
     end
   end
@@ -115,7 +130,7 @@ describe Prawn::SVG::Elements::Gradient do
   context 'when gradientTransform is specified' do
     let(:svg) do
       <<-SVG
-        <linearGradient id="flag" gradientTransform="translateX(10) scale(2)" x1="0" y1="0" x2="10" y2="10">
+        <linearGradient id="flag" gradientTransform="translateX(0.5) scale(2)" x1="0" y1="0" x2="1" y2="1">
           <stop offset="0" stop-color="red"/>
           <stop offset="1" stop-color="blue"/>
         </linearGradient>
@@ -123,13 +138,54 @@ describe Prawn::SVG::Elements::Gradient do
     end
 
     it 'passes in the transform via the apply_transformations option' do
-      arguments = element.gradient_arguments(double(bounding_box: [0, 0, 10, 10]))
+      arguments = element.gradient_arguments(double(bounding_box: [100, 100, 200, 0]))
+
+      expect(arguments).to eq(
+        from:         [0.0, 0.0],
+        to:           [1.0, 1.0],
+        stops:        [{ offset: 0, color: 'ff0000', opacity: 1.0 }, { offset: 1, color: '0000ff', opacity: 1.0 }],
+        matrix:       Matrix[[200.0, 0.0, 150.0], [0.0, -200.0, 100.0], [0.0, 0.0, 1.0]],
+        wrap:         :pad,
+        bounding_box: [100, 100, 200, 0]
+      )
+    end
+  end
+
+  context 'when a gradient is linked to another' do
+    let(:svg) do
+      <<-SVG
+        <svg>
+          <linearGradient id="flag" gradientUnits="userSpaceOnUse" x1="100" y1="500" x2="200" y2="600">
+            <stop offset="0" stop-color="red"/>
+            <stop offset="1" stop-color="blue"/>
+          </linearGradient>
+
+          <linearGradient id="flag-2" href="#flag" x1="150" x2="220" />
+
+          <linearGradient id="flag-3" href="#flag-2" x1="170" />
+        </svg>
+      SVG
+    end
+
+    it 'correctly inherits the attributes from the parent element' do
+      arguments = document.gradients['flag-2'].gradient_arguments(double(bounding_box: [100, 100, 200, 0]))
+      expect(arguments).to eq(
+        from:         [150.0, 500.0],
+        to:           [220.0, 600.0],
+        stops:        [{ offset: 0, color: 'ff0000', opacity: 1.0 }, { offset: 1, color: '0000ff', opacity: 1.0 }],
+        matrix:       Matrix[[1.0, 0.0, 0.0], [0.0, -1.0, 600.0], [0.0, 0.0, 1.0]],
+        wrap:         :pad,
+        bounding_box: [100, 100, 200, 0]
+      )
 
+      arguments = document.gradients['flag-3'].gradient_arguments(double(bounding_box: [100, 100, 200, 0]))
       expect(arguments).to eq(
-        from:                  [0, 0],
-        to:                    [10, 10],
-        stops:                 [[0, 'ff0000'], [1, '0000ff']],
-        apply_transformations: [2, 0, 0, 2, 10, 0]
+        from:         [170.0, 500.0],
+        to:           [220.0, 600.0],
+        stops:        [{ offset: 0, color: 'ff0000', opacity: 1.0 }, { offset: 1, color: '0000ff', opacity: 1.0 }],
+        matrix:       Matrix[[1.0, 0.0, 0.0], [0.0, -1.0, 600.0], [0.0, 0.0, 1.0]],
+        wrap:         :pad,
+        bounding_box: [100, 100, 200, 0]
       )
     end
   end

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

@@ -69,21 +69,19 @@ RSpec.describe Prawn::SVG::Elements::Marker do
           ['rectangle', [[-0.5, 600.0], 4.0, 3.0], {}, []],
           ['clip', [], {}, []],
           ['transformation_matrix', [0.3, 0, 0, 0.3, 0, 0], {}, []],
-          ['transparent', [1.0, 1.0], {}, [
-            ['fill_color', ['000000'], {}, []],
-            ['line_width', [1.0], {}, []],
-            ['cap_style', [:butt], {}, []],
-            ['join_style', [:miter], {}, []],
-            ['undash', [], {}, []],
-            ['save', [], {}, []],
-            ['fill', [], {}, [
-              ['move_to', [[0.0, 600.0]], {}, []],
-              ['line_to', [[10.0, 595.0]], {}, []],
-              ['line_to', [[0.0, 590.0]], {}, []],
-              ['close_path', [], {}, []]
-            ]],
-            ['restore', [], {}, []]
-          ]]
+          ['fill_color', ['000000'], {}, []],
+          ['line_width', [1.0], {}, []],
+          ['cap_style', [:butt], {}, []],
+          ['join_style', [:miter], {}, []],
+          ['undash', [], {}, []],
+          ['save', [], {}, []],
+          ['fill', [], {}, [
+            ['move_to', [[0.0, 600.0]], {}, []],
+            ['line_to', [[10.0, 595.0]], {}, []],
+            ['line_to', [[0.0, 590.0]], {}, []],
+            ['close_path', [], {}, []]
+          ]],
+          ['restore', [], {}, []]
         ]],
         ['restore', [], {}, []]
       ]

data/spec/prawn/svg/funciri_spec.rb

@@ -0,0 +1,59 @@
+require 'spec_helper'
+
+describe Prawn::SVG::FuncIRI do
+  describe '.parse' do
+    it 'parses a URL' do
+      expect(described_class.parse('url(#foo)')).to eq(described_class.new('#foo'))
+    end
+
+    it 'parses a URL with whitespace' do
+      expect(described_class.parse('url( #foo )')).to eq(described_class.new('#foo'))
+    end
+
+    it 'parses a URL with quotes' do
+      expect(described_class.parse('url("#foo")')).to eq(described_class.new('#foo'))
+    end
+
+    it 'parses a URL with quotes and whitespace' do
+      expect(described_class.parse('url( "#foo" )')).to eq(described_class.new('#foo'))
+    end
+
+    it 'parses a URL with double quotes' do
+      expect(described_class.parse('url("#foo")')).to eq(described_class.new('#foo'))
+    end
+
+    it 'parses a URL with double quotes and whitespace' do
+      expect(described_class.parse('url( "#foo" )')).to eq(described_class.new('#foo'))
+    end
+
+    it 'parses a URL with single quotes' do
+      expect(described_class.parse("url('#foo')")).to eq(described_class.new('#foo'))
+    end
+
+    it 'parses a URL with single quotes and whitespace' do
+      expect(described_class.parse("url( '#foo' )")).to eq(described_class.new('#foo'))
+    end
+
+    it 'parses a URL with both single and double quotes' do
+      expect(described_class.parse('url("#foo")')).to eq(described_class.new('#foo'))
+    end
+
+    it 'parses a URL with both single and double quotes and whitespace' do
+      expect(described_class.parse('url( "#foo" )')).to eq(described_class.new('#foo'))
+    end
+
+    it 'parses a URL with both single and double quotes and whitespace' do
+      expect(described_class.parse('url( "#foo" )')).to eq(described_class.new('#foo'))
+    end
+
+    it 'parses a URL with escaped quotes' do
+      expect(described_class.parse('url("\\#foo")')).to eq(described_class.new('#foo'))
+    end
+
+    it 'ignores a non-URL value' do
+      expect(described_class.parse('foo')).to be_nil
+      expect(described_class.parse('foo(1)')).to be_nil
+      expect(described_class.parse('url(1, 2)')).to be_nil
+    end
+  end
+end

data/spec/prawn/svg/length_spec.rb

@@ -0,0 +1,89 @@
+require 'spec_helper'
+
+describe Prawn::SVG::Length do
+  describe '.parse' do
+    it 'parses a length' do
+      expect(described_class.parse('1.23em')).to eq(described_class.new(1.23, :em))
+    end
+
+    it 'parses a length with a positive sign' do
+      expect(described_class.parse('+1.23em')).to eq(described_class.new(1.23, :em))
+    end
+
+    it 'parses a length with a negative sign' do
+      expect(described_class.parse('-1.23em')).to eq(described_class.new(-1.23, :em))
+    end
+
+    it 'parses a length with the unit in caps' do
+      expect(described_class.parse('1.23EM')).to eq(described_class.new(1.23, :em))
+    end
+
+    it 'parses a length with no decimal points' do
+      expect(described_class.parse('1em')).to eq(described_class.new(1, :em))
+    end
+
+    it 'parses a length with no unit' do
+      expect(described_class.parse('1.23')).to eq(described_class.new(1.23, nil))
+    end
+
+    it 'allows numbers without a leading zero' do
+      expect(described_class.parse('.23em')).to eq(described_class.new(0.23, :em))
+    end
+
+    it 'does not allow numbers with a trailing dot' do
+      expect(described_class.parse('1.em')).to be nil
+    end
+
+    it 'does not allow units it does not recognise' do
+      expect(described_class.parse('1.23foo')).to be nil
+    end
+
+    context 'when positive_only is true' do
+      it 'does not allow negative numbers' do
+        expect(described_class.parse('-1.23em', positive_only: true)).to be nil
+      end
+
+      it 'does allow zero' do
+        expect(described_class.parse('0em', positive_only: true)).to eq(described_class.new(0, :em))
+      end
+
+      it 'does allow positive numbers' do
+        expect(described_class.parse('1.23em', positive_only: true)).to eq(described_class.new(1.23, :em))
+      end
+    end
+  end
+
+  describe '#to_pixels' do
+    it 'converts a em-unit length to pixels' do
+      expect(described_class.new(2.5, :em).to_pixels(nil, 12)).to eq(12 * 2.5)
+    end
+
+    it 'converts a rem-unit length to pixels' do
+      expect(described_class.new(2.5, :rem).to_pixels(nil, 12)).to eq(16 * 2.5)
+    end
+
+    it 'converts a ex-unit length to pixels' do
+      expect(described_class.new(2.5, :ex).to_pixels(nil, 12)).to eq(6 * 2.5)
+    end
+
+    it 'converts a pc-unit length to pixels' do
+      expect(described_class.new(2.5, :pc).to_pixels(nil, 12)).to eq(37.5)
+    end
+
+    it 'converts a in-unit length to pixels' do
+      expect(described_class.new(2.5, :in).to_pixels(nil, 12)).to eq(180)
+    end
+
+    it 'converts a cm-unit length to pixels' do
+      expect(described_class.new(2.5, :cm).to_pixels(nil, 12)).to be_within(0.001).of(70.866)
+    end
+
+    it 'converts a mm-unit length to pixels' do
+      expect(described_class.new(2.5, :mm).to_pixels(nil, 12)).to be_within(0.001).of(7.087)
+    end
+
+    it 'returns the value for an unknown unit' do
+      expect(described_class.new(2.5, nil).to_pixels(nil, 12)).to eq(2.5)
+    end
+  end
+end