prawn-svg 0.35.1 → 0.36.0

data/spec/prawn/svg/paint_spec.rb

@@ -0,0 +1,96 @@
+require 'spec_helper'
+
+RSpec.describe Prawn::SVG::Paint do
+  let(:red) { Prawn::SVG::Color::RGB.new('ff0000') }
+
+  describe '.parse' do
+    it 'parses a color' do
+      expect(described_class.parse('red')).to eq(described_class.new(red, nil))
+    end
+
+    it 'parses an rgb color with an icc color, ignoring the icc color' do
+      expect(described_class.parse('rgb(255, 0, 0) icc-color(1)')).to eq(described_class.new(red, nil))
+    end
+
+    it 'parses a URL' do
+      expect(described_class.parse('url(#foo)')).to eq(described_class.new(:none, '#foo'))
+    end
+
+    it 'parses a keyword' do
+      expect(described_class.parse('NONE')).to eq(described_class.new(:none, nil))
+      expect(described_class.parse('currentColor')).to eq(described_class.new(:currentcolor, nil))
+    end
+
+    it 'parses a URL with a fallback keyword' do
+      expect(described_class.parse('url(#foo) none')).to eq(described_class.new(:none, '#foo'))
+    end
+
+    it 'parses a URL with a fallback color' do
+      expect(described_class.parse('url(#foo) red')).to eq(described_class.new(red, '#foo'))
+    end
+
+    it 'parses a URL with a fallback color and an icc color, ignoring the icc color' do
+      expect(described_class.parse('url(#foo) red icc-color(1)')).to eq(described_class.new(red, '#foo'))
+    end
+
+    it 'returns nil if the value is unrecognised' do
+      expect(described_class.parse('foo')).to be_nil
+    end
+
+    it 'returns nil if the url has multiple arguments' do
+      expect(described_class.parse('url(#foo, bar)')).to be_nil
+    end
+  end
+
+  describe '#none?' do
+    it 'returns true if the color is none' do
+      expect(described_class.new(:none, nil).none?).to be(true)
+    end
+
+    it 'returns true if the color is none and the URL is unresolved' do
+      paint = described_class.new(:none, '#foo')
+      paint.instance_variable_set(:@unresolved_url, true)
+      expect(paint.none?).to be(true)
+    end
+
+    it 'returns false if the color is not none' do
+      expect(described_class.new(Prawn::SVG::Color::RGB.new('ff0000'), nil).none?).to be(false)
+    end
+  end
+
+  describe '#resolve' do
+    it 'returns the current color if the color is currentcolor' do
+      current_color = double
+      paint = described_class.new(:currentcolor, nil)
+      expect(paint.resolve(nil, current_color, :rgb)).to eq current_color
+    end
+
+    it 'returns the nil if the color is none' do
+      current_color = double
+      paint = described_class.new(:none, nil)
+      expect(paint.resolve(nil, current_color, :rgb)).to be nil
+    end
+
+    it 'returns the gradient if the URL is resolvable' do
+      gradient = double
+      paint = described_class.new(:none, '#foo')
+      expect(paint.resolve({ 'foo' => gradient }, nil, :rgb)).to eq(gradient)
+    end
+
+    it 'falls back to the color if the URL is unresolvable' do
+      paint = described_class.new(red, '#foo')
+      expect(paint.resolve(nil, nil, :rgb)).to eq red
+      expect(paint.resolve({}, nil, :rgb)).to eq red
+    end
+
+    it 'returns the color if the color is not currentcolor or none' do
+      paint = described_class.new(red, nil)
+      expect(paint.resolve(nil, nil, :rgb)).to eq red
+    end
+
+    it 'converts the color to CMYK if the color mode is CMYK' do
+      paint = described_class.new(red, nil)
+      expect(paint.resolve(nil, nil, :cmyk)).to eq Prawn::SVG::Color::CMYK.new([0, 100, 100, 0])
+    end
+  end
+end

data/spec/prawn/svg/pathable_spec.rb

@@ -57,7 +57,7 @@ RSpec.describe Prawn::SVG::Pathable do
 
     context 'with marker-start attribute specified' do
       before do
-        subject.properties.marker_start = 'url(#triangle)'
+        subject.properties.marker_start = Prawn::SVG::FuncIRI.new('#triangle')
       end
 
       it 'calls apply_marker on the marker' do
@@ -68,7 +68,7 @@ RSpec.describe Prawn::SVG::Pathable do
 
     context 'with marker-mid attribute specified' do
       before do
-        subject.properties.marker_mid = 'url(#triangle)'
+        subject.properties.marker_mid = Prawn::SVG::FuncIRI.new('#triangle')
       end
 
       it 'calls apply_marker on the marker' do
@@ -80,7 +80,7 @@ RSpec.describe Prawn::SVG::Pathable do
 
     context 'with marker-end attribute specified' do
       before do
-        subject.properties.marker_end = 'url(#triangle)'
+        subject.properties.marker_end = Prawn::SVG::FuncIRI.new('#triangle')
       end
 
       it 'calls apply_marker on the marker' do

data/spec/prawn/svg/pdfmatrix_spec.rb

@@ -0,0 +1,60 @@
+require 'spec_helper'
+
+RSpec.describe Prawn::SVG::PDFMatrix do
+  subject do
+    obj = Object.new
+    obj.extend(Prawn::SVG::PDFMatrix)
+    obj
+  end
+
+  describe '#load_matrix' do
+    it 'converts a PDF-style matrix into a Ruby Matrix' do
+      expect(subject.load_matrix([1.0, 0.0, 0.0, 1.0, 5.0, 7.0])).to eq(Matrix[
+        [1.0, 0.0, 5.0],
+        [0.0, 1.0, 7.0],
+        [0.0, 0.0, 1.0]
+      ])
+    end
+
+    it 'returns the same Ruby Matrix if it has the correct dimensions' do
+      matrix = Matrix[[1.0, 0.0, 5.0], [0.0, 1.0, 7.0], [0.0, 0.0, 1.0]]
+      expect(subject.load_matrix(matrix)).to eq(matrix)
+    end
+
+    it 'raises an error for unexpected Ruby matrices' do
+      matrix = Matrix.identity(4)
+      expect { subject.load_matrix(matrix) }.to raise_error(ArgumentError)
+    end
+
+    it 'raises an error for unexpected PDF-style matrices' do
+      matrix = [1.0, 2.0, 3.0, 4.0]
+      expect { subject.load_matrix(matrix) }.to raise_error(ArgumentError)
+    end
+  end
+
+  describe '#matrix_for_pdf' do
+    it 'converts a Ruby Matrix into the correct format for PDF' do
+      matrix = Matrix[[1.0, 0.0, 5.0], [0.0, 1.0, 7.0], [0.0, 0.0, 1.0]]
+      expect(subject.matrix_for_pdf(matrix)).to eq([1.0, 0.0, 0.0, 1.0, 5.0, 7.0])
+    end
+  end
+
+  describe '#rotation_matrix' do
+    let(:angle) { 45 * Math::PI / 180.0 }
+    let(:inv_root_2) { 0.707 }
+
+    context 'in PDF space' do
+      it 'returns the expected matrix' do
+        matrix = Matrix[[inv_root_2, inv_root_2, 0], [-inv_root_2, inv_root_2, 0], [0, 0, 1]]
+        expect(subject.rotation_matrix(angle).round(3)).to eq(matrix)
+      end
+    end
+
+    context 'in SVG space' do
+      it 'returns the expected matrix' do
+        matrix = Matrix[[inv_root_2, -inv_root_2, 0], [inv_root_2, inv_root_2, 0], [0, 0, 1]]
+        expect(subject.rotation_matrix(angle, space: :svg).round(3)).to eq(matrix)
+      end
+    end
+  end
+end

data/spec/prawn/svg/percentage_spec.rb

@@ -0,0 +1,60 @@
+require 'spec_helper'
+
+describe Prawn::SVG::Percentage do
+  describe '.parse' do
+    it 'parses a percentage' do
+      expect(described_class.parse('1.23%')).to eq(described_class.new(1.23))
+    end
+
+    it 'parses a percentage with a positive sign' do
+      expect(described_class.parse('+1.23%')).to eq(described_class.new(1.23))
+    end
+
+    it 'parses a percentage with a negative sign' do
+      expect(described_class.parse('-1.23%')).to eq(described_class.new(-1.23))
+    end
+
+    it 'parses a percentage with no decimal points' do
+      expect(described_class.parse('1%')).to eq(described_class.new(1))
+    end
+
+    it 'does not parse a percentage with no number' do
+      expect(described_class.parse('%')).to be nil
+    end
+
+    it 'does not parse a percentage with a trailing dot' do
+      expect(described_class.parse('1.%')).to be nil
+    end
+
+    it 'requires that the percentage sign is specified' do
+      expect(described_class.parse('1.23')).to be nil
+    end
+
+    context 'when positive_only is true' do
+      it 'does not allow negative numbers' do
+        expect(described_class.parse('-1.23%', positive_only: true)).to be nil
+      end
+
+      it 'does allow zero' do
+        expect(described_class.parse('0%', positive_only: true)).to eq(described_class.new(0))
+      end
+
+      it 'does allow positive numbers' do
+        expect(described_class.parse('1.23%', positive_only: true)).to eq(described_class.new(1.23))
+      end
+    end
+  end
+
+  describe '#to_factor' do
+    it 'converts a percentage to a factor' do
+      expect(described_class.new(2.5).to_factor).to eq(0.025)
+    end
+  end
+
+  describe '#to_pixels' do
+    it 'converts a percentage to pixels' do
+      expect(described_class.new(2.5).to_pixels(100, nil)).to eq(2.5)
+      expect(described_class.new(2.5).to_pixels(200, nil)).to eq(5)
+    end
+  end
+end

data/spec/prawn/svg/properties_spec.rb

@@ -14,13 +14,13 @@ RSpec.describe Prawn::SVG::Properties do
     it 'sets a property' do
       result = subject.set('color', 'red')
       expect(result).to be
-      expect(subject.color).to eq 'red'
+      expect(subject.color).to eq Prawn::SVG::Color::RGB.new('ff0000')
     end
 
     it 'handles property names that are not lower case' do
       result = subject.set('COLor', 'red')
       expect(result).to be
-      expect(subject.color).to eq 'red'
+      expect(subject.color).to eq Prawn::SVG::Color::RGB.new('ff0000')
     end
 
     it 'right-cases and strips keywords' do
@@ -28,22 +28,99 @@ RSpec.describe Prawn::SVG::Properties do
       expect(subject.stroke_linecap).to eq 'round'
     end
 
-    it "doesn't right-case values that aren't recognised as keywords" do
-      subject.set('color', 'Red')
-      expect(subject.color).to eq 'Red'
+    it 'ignores invalid values, retaining any previously set value' do
+      subject.set('display', 'invalid')
+      expect(subject.display).to be nil
+      subject.set('display', 'none')
+      expect(subject.display).to eq 'none'
+      subject.set('display', 'invalid')
+      expect(subject.display).to eq 'none'
     end
 
-    it "sets a 'keyword restricted' property to its default if the value doesn't match a keyword" do
-      subject.set('stroke-linecap', 'invalid')
-      expect(subject.stroke_linecap).to eq 'butt'
+    context 'when setting the font shorthand property' do
+      it 'sets font style, weight, size, and family' do
+        subject.set('font', 'italic bold 12px/30px "New Font", sans-serif')
+        expect(subject.font_style).to eq 'italic'
+        expect(subject.font_weight).to eq 'bold'
+        expect(subject.font_variant).to eq 'normal'
+        expect(subject.font_size).to eq Prawn::SVG::Length.parse('12px')
+        expect(subject.font_family).to eq '"New Font", sans-serif'
+      end
+
+      it 'sets font style, weight, variant, size, and family' do
+        subject.set('font', 'italic small-caps bold 12px/30px "New Font", sans-serif')
+        expect(subject.font_style).to eq 'italic'
+        expect(subject.font_weight).to eq 'bold'
+        expect(subject.font_variant).to eq 'small-caps'
+        expect(subject.font_size).to eq Prawn::SVG::Length.parse('12px')
+        expect(subject.font_family).to eq '"New Font", sans-serif'
+      end
+
+      it 'sets size and family, defaulting everything else to normal' do
+        subject.set('font-weight', 'bold')
+        subject.set('font-style', 'italic')
+        subject.set('font-variant', 'small-caps')
+
+        subject.set('font', '12px fontname')
+        expect(subject.font_style).to eq 'normal'
+        expect(subject.font_weight).to eq 'normal'
+        expect(subject.font_variant).to eq 'normal'
+        expect(subject.font_size).to eq Prawn::SVG::Length.parse('12px')
+        expect(subject.font_family).to eq 'fontname'
+      end
+
+      it 'suports the inherit keyword' do
+        subject.set('font', 'inherit')
+        expect(subject.font_style).to eq 'inherit'
+        expect(subject.font_weight).to eq 'inherit'
+        expect(subject.font_variant).to eq 'inherit'
+        expect(subject.font_size).to eq 'inherit'
+        expect(subject.font_family).to eq 'inherit'
+      end
+
+      it 'supports the standard font keyword, menu' do
+        subject.set('font', 'menu')
+        expect(subject.font_style).to eq 'normal'
+        expect(subject.font_weight).to eq 'normal'
+        expect(subject.font_variant).to eq 'normal'
+        expect(subject.font_size).to eq 'medium'
+        expect(subject.font_family).to eq 'sans-serif'
+      end
+
+      it 'does nothing if an unrecognised keyword is used' do
+        subject.set('font', 'invalid')
+        expect(subject.font_style).to be nil
+        expect(subject.font_weight).to be nil
+        expect(subject.font_variant).to be nil
+        expect(subject.font_size).to be nil
+        expect(subject.font_family).to be nil
+      end
+
+      it 'does nothing if the font size is not valid' do
+        subject.set('font', '23bad sans-serif')
+        expect(subject.font_style).to be nil
+        expect(subject.font_weight).to be nil
+        expect(subject.font_variant).to be nil
+        expect(subject.font_size).to be nil
+        expect(subject.font_family).to be nil
+      end
+
+      it 'does nothing if one of the font keywords is not recognised' do
+        subject.set('font', 'italic invalid bold 12px/30px "New Font", sans-serif')
+        expect(subject.font_style).to be nil
+        expect(subject.font_weight).to be nil
+        expect(subject.font_variant).to be nil
+        expect(subject.font_size).to be nil
+        expect(subject.font_family).to be nil
+      end
     end
   end
 
   describe '#load_hash' do
     it 'uses #set to load in a hash of properties' do
       subject.load_hash('stroke' => 'blue', 'fill' => 'green', 'stroke-linecap' => 'Round')
-      expect(subject.stroke).to eq 'blue'
-      expect(subject.fill).to eq 'green'
+      expect(subject.stroke).to eq Prawn::SVG::Paint.new(Prawn::SVG::Color::RGB.new('0000ff'))
+      expect(subject.fill).to eq Prawn::SVG::Paint.new(Prawn::SVG::Color::RGB.new('008000'))
       expect(subject.stroke_linecap).to eq 'round'
     end
   end
@@ -54,7 +131,7 @@ RSpec.describe Prawn::SVG::Properties do
     it 'auto-inherits inheritable properties when the property is not supplied' do
       subject.set('color', 'green')
       subject.compute_properties(other)
-      expect(subject.color).to eq 'green'
+      expect(subject.color).to eq Prawn::SVG::Color::RGB.new('008000')
     end
 
     it "doesn't auto-inherit non-inheritable properties" do
@@ -74,112 +151,52 @@ RSpec.describe Prawn::SVG::Properties do
       subject.set('color', 'green')
       other.set('color', 'red')
       subject.compute_properties(other)
-      expect(subject.color).to eq 'red'
+      expect(subject.color).to eq Prawn::SVG::Color::RGB.new('ff0000')
     end
+  end
 
-    describe 'font size' do
-      before do
-        subject.font_size = '15'
-        other.font_size = font_size
-      end
-
-      context 'when given a % as a font-size' do
-        let(:font_size) { '120%' }
-
-        it 'calculates the new font size' do
-          subject.compute_properties(other)
-          expect(subject.font_size).to eq '18.0'
-        end
-      end
-
-      context "when given 'larger' as a font-size" do
-        let(:font_size) { 'larger' }
-
-        it 'calculates the new font size' do
-          subject.compute_properties(other)
-          expect(subject.font_size).to eq '19.0'
-        end
-      end
-
-      context "when given 'smaller' as a font-size" do
-        let(:font_size) { 'smaller' }
-
-        it 'calculates the new font size' do
-          subject.compute_properties(other)
-          expect(subject.font_size).to eq '11.0'
-        end
-      end
-
-      context "when given a value in 'em' as a font-size" do
-        let(:font_size) { '2.5em' }
-
-        it 'calculates the new font size' do
-          subject.compute_properties(other)
-          expect(subject.font_size).to eq '37.5'
-        end
-      end
-
-      context "when given a value in 'rem' as a font-size" do
-        let(:font_size) { '2.5rem' }
-
-        it 'calculates the new font size' do
-          subject.compute_properties(other)
-          expect(subject.font_size).to eq '40.0'
-        end
-      end
-
-      context "when given a value in 'px' as a font-size" do
-        let(:font_size) { '19.5px' }
-
-        it 'uses the font size specified' do
-          subject.compute_properties(other)
-          expect(subject.font_size).to eq '19.5'
-        end
-      end
-
-      context "when given a value in 'pt' as a font-size" do
-        let(:font_size) { '19.5pt' }
-
-        it 'uses the font size specified' do
-          subject.compute_properties(other)
-          expect(subject.font_size).to eq '19.5'
-        end
-      end
-
-      context 'when given a value without units as a font-size' do
-        let(:font_size) { '19.5' }
-
-        it 'uses the font size specified' do
-          subject.compute_properties(other)
-          expect(subject.font_size).to eq '19.5'
-        end
-      end
-
-      context "when given the keyword 'inherit' as a font-size" do
-        let(:font_size) { 'inherit' }
+  describe '#numeric_font_size' do
+    def calculate
+      properties = Prawn::SVG::Properties.new
+      properties.compute_properties(subject)
+      properties.numeric_font_size
+    end
 
-        it 'uses the font size specified by the parent' do
-          subject.compute_properties(other)
-          expect(subject.font_size).to eq '15'
+    cases =
+      {
+        Prawn::SVG::Length.parse('18.5pt') => 18.5,
+        Prawn::SVG::Percentage.new(120)    => 19.2,
+        19.5                               => 19.5,
+        'larger'                           => 20,
+        'smaller'                          => 12,
+        nil                                => 16,
+        'inherit'                          => 16,
+        'x-large'                          => 24
+      }
+
+    cases.each do |font_size, expected|
+      context "when the font size is #{font_size.inspect}" do
+        before { subject.font_size = font_size }
+
+        it 'returns the correct number' do
+          expect(calculate).to eq expected
         end
       end
     end
-  end
 
-  describe '#numerical_font_size' do
-    context 'when the font size is a number' do
-      before { subject.font_size = '16.5' }
+    context 'with a font-size of 1.2em, under a parent with a font size of x-large' do
+      it 'returns 24 * 1.2' do
+        a = Prawn::SVG::Properties.new
+        a.set('font-size', 'x-large')
 
-      it 'returns the number as a float' do
-        expect(subject.numerical_font_size).to eq 16.5
-      end
-    end
+        b = Prawn::SVG::Properties.new
+        b.set('font-size', '1.2em')
 
-    context 'when the font size is one of the keyword size specifiers' do
-      before { subject.font_size = 'x-large' }
+        properties = Prawn::SVG::Properties.new
+        properties.compute_properties(a)
+        properties.compute_properties(b)
 
-      it 'returns the font size number corresponding with the keyword' do
-        expect(subject.numerical_font_size).to eq 24
+        expect(properties.numeric_font_size.round(1)).to eq 28.8
       end
     end
   end

data/spec/prawn/svg/transform_parser_spec.rb

@@ -6,7 +6,7 @@ RSpec.describe Prawn::SVG::TransformParser do
     include Prawn::SVG::TransformParser
 
     State = Struct.new(:viewport_sizing)
-    Properties = Struct.new(:numerical_font_size)
+    Properties = Struct.new(:numeric_font_size)
     Document = Struct.new(:sizing)
 
     def document
@@ -30,27 +30,27 @@ RSpec.describe Prawn::SVG::TransformParser do
 
   context 'with no transform' do
     let(:transform) { '' }
-    it { is_expected.to eq [1, 0, 0, 1, 0, 0] }
+    it { is_expected.to eq Matrix[[1, 0, 0], [0, 1, 0], [0, 0, 1]] }
   end
 
   context 'with translate' do
     let(:transform) { 'translate(10 20)' }
-    it { is_expected.to eq [1, 0, 0, 1, 10, -20] }
+    it { is_expected.to eq Matrix[[1, 0, 10.0], [0, 1, -20.0], [0, 0, 1.0]] }
   end
 
   context 'with single argument translate' do
     let(:transform) { 'translate(10)' }
-    it { is_expected.to eq [1, 0, 0, 1, 10, 0] }
+    it { is_expected.to eq Matrix[[1, 0, 10.0], [0, 1, 0.0], [0, 0, 1.0]] }
   end
 
   context 'with translateX' do
     let(:transform) { 'translateX(10)' }
-    it { is_expected.to eq [1, 0, 0, 1, 10, 0] }
+    it { is_expected.to eq Matrix[[1, 0, 10.0], [0, 1, 0.0], [0, 0, 1.0]] }
   end
 
   context 'with translateY' do
     let(:transform) { 'translateY(10)' }
-    it { is_expected.to eq [1, 0, 0, 1, 0, -10] }
+    it { is_expected.to eq Matrix[[1, 0, 0.0], [0, 1, -10.0], [0, 0, 1.0]] }
   end
 
   let(:sin30) { Math.sin(30 * Math::PI / 180.0) }
@@ -59,36 +59,36 @@ RSpec.describe Prawn::SVG::TransformParser do
 
   context 'with single argument rotate' do
     let(:transform) { 'rotate(30)' }
-    it { is_expected.to eq [cos30, -sin30, sin30, cos30, 0, 0] }
+    it { is_expected.to eq Matrix[[cos30, sin30, 0], [-sin30, cos30, 0], [0.0, 0.0, 1]] }
   end
 
   context 'with triple argument rotate' do
     let(:transform) { 'rotate(30 100 200)' }
-    it { is_expected.to eq [cos30, -sin30, sin30, cos30, 113.39745962155611, 23.205080756887753] }
+    it { is_expected.to eq Matrix[[cos30, sin30, 113.39745962155611], [-sin30, cos30, 23.205080756887753], [0.0, 0.0, 1.0]] }
   end
 
   context 'with scale' do
     let(:transform) { 'scale(1.5)' }
-    it { is_expected.to eq [1.5, 0, 0, 1.5, 0, 0] }
+    it { is_expected.to eq Matrix[[1.5, 0.0, 0], [0.0, 1.5, 0], [0.0, 0.0, 1]] }
   end
 
   context 'with skewX' do
     let(:transform) { 'skewX(30)' }
-    it { is_expected.to eq [1, 0, -tan30, 1, 0, 0] }
+    it { is_expected.to eq Matrix[[1, -tan30, 0], [0, 1.0, 0], [0, 0.0, 1]] }
   end
 
   context 'with skewY' do
     let(:transform) { 'skewY(30)' }
-    it { is_expected.to eq [1, -tan30, 0, 1, 0, 0] }
+    it { is_expected.to eq Matrix[[1.0, 0, 0], [-tan30, 1, 0], [0.0, 0, 1]] }
   end
 
   context 'with matrix' do
     let(:transform) { 'matrix(1 2 3 4 5 6)' }
-    it { is_expected.to eq [1, -2, -3, 4, 5, -6] }
+    it { is_expected.to eq Matrix[[1.0, -3.0, 5.0], [-2.0, 4.0, -6.0], [0.0, 0.0, 1.0]] }
   end
 
   context 'with multiple' do
     let(:transform) { 'scale(2) translate(7) scale(3)' }
-    it { is_expected.to eq [6, 0, 0, 6, 14, 0] }
+    it { is_expected.to eq Matrix[[6.0, 0.0, 14.0], [0.0, 6.0, 0.0], [0.0, 0.0, 1.0]] }
   end
 end