prawn-svg 0.34.1 → 0.35.0

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

@@ -1,4 +1,4 @@
-require File.dirname(__FILE__) + '/../../../spec_helper'
+require "#{File.dirname(__FILE__)}/../../../spec_helper"
 
 describe Prawn::SVG::Calculators::AspectRatio do
   def test(*args)
@@ -6,90 +6,90 @@ describe Prawn::SVG::Calculators::AspectRatio do
     [[aspect.width, aspect.height], [aspect.x, aspect.y]]
   end
 
-  it "handles none" do
-    expect(test "none", [50,80], [100,100]).to eq [[50, 80], [0, 0]]
-    expect(test "none", [100,100], [50,80]).to eq [[100, 100], [0, 0]]
+  it 'handles none' do
+    expect(test('none', [50, 80], [100, 100])).to eq [[50, 80], [0, 0]]
+    expect(test('none', [100, 100], [50, 80])).to eq [[100, 100], [0, 0]]
   end
 
-  context "using meet" do
-    context "with smaller containers than objects" do
-      let(:coords) { [[50,80], [100,100]] }
+  context 'using meet' do
+    context 'with smaller containers than objects' do
+      let(:coords) { [[50, 80], [100, 100]] }
 
-      it "correctly calculates the result" do
-        expect(test "xMidYMid meet", *coords).to eq [[50, 50], [0, 15]]
-        expect(test "xMinYMin meet", *coords).to eq [[50, 50], [0, 0]]
-        expect(test "xMaxYMax meet", *coords).to eq [[50, 50], [0, 30]]
+      it 'correctly calculates the result' do
+        expect(test('xMidYMid meet', *coords)).to eq [[50, 50], [0, 15]]
+        expect(test('xMinYMin meet', *coords)).to eq [[50, 50], [0, 0]]
+        expect(test('xMaxYMax meet', *coords)).to eq [[50, 50], [0, 30]]
       end
     end
 
-    context "with bigger containers than objects" do
-      let(:coords) { [[100,80], [50,50]] }
+    context 'with bigger containers than objects' do
+      let(:coords) { [[100, 80], [50, 50]] }
 
-      it "correctly calculates the result" do
-        expect(test "xMidYMid meet", *coords).to eq [[80, 80], [10, 0]]
-        expect(test "xMinYMin meet", *coords).to eq [[80, 80], [0, 0]]
-        expect(test "xMaxYMax meet", *coords).to eq [[80, 80], [20, 0]]
+      it 'correctly calculates the result' do
+        expect(test('xMidYMid meet', *coords)).to eq [[80, 80], [10, 0]]
+        expect(test('xMinYMin meet', *coords)).to eq [[80, 80], [0, 0]]
+        expect(test('xMaxYMax meet', *coords)).to eq [[80, 80], [20, 0]]
       end
     end
 
-    context "with bigger square containers" do
-      let(:coords) { [[100,100], [50,80]] }
+    context 'with bigger square containers' do
+      let(:coords) { [[100, 100], [50, 80]] }
 
-      it "correctly calculates the result" do
-        expect(test "xMidYMid meet", *coords).to eq [[62.5, 100], [18.75, 0]]
-        expect(test "xMinYMin meet", *coords).to eq [[62.5, 100], [0, 0]]
-        expect(test "xMaxYMax meet", *coords).to eq [[62.5, 100], [37.5, 0]]
+      it 'correctly calculates the result' do
+        expect(test('xMidYMid meet', *coords)).to eq [[62.5, 100], [18.75, 0]]
+        expect(test('xMinYMin meet', *coords)).to eq [[62.5, 100], [0, 0]]
+        expect(test('xMaxYMax meet', *coords)).to eq [[62.5, 100], [37.5, 0]]
       end
     end
 
-    context "with oddly shaped containers" do
-      let(:coords) { [[100,20], [50,50]] }
+    context 'with oddly shaped containers' do
+      let(:coords) { [[100, 20], [50, 50]] }
 
-      it "correctly calculates the result" do
-        expect(test "xMidYMid meet", *coords).to eq [[20, 20], [40, 0]]
-        expect(test "xMinYMin meet", *coords).to eq [[20, 20], [0, 0]]
-        expect(test "xMaxYMax meet", *coords).to eq [[20, 20], [80, 0]]
+      it 'correctly calculates the result' do
+        expect(test('xMidYMid meet', *coords)).to eq [[20, 20], [40, 0]]
+        expect(test('xMinYMin meet', *coords)).to eq [[20, 20], [0, 0]]
+        expect(test('xMaxYMax meet', *coords)).to eq [[20, 20], [80, 0]]
       end
     end
   end
 
-  context "using slice" do
-    context "with smaller containers than objects" do
-      let(:coords) { [[50,80], [100,100]] }
+  context 'using slice' do
+    context 'with smaller containers than objects' do
+      let(:coords) { [[50, 80], [100, 100]] }
 
-      it "correctly calculates the result" do
-        expect(test "xMidYMid slice", *coords).to eq [[80, 80], [-15, 0]]
-        expect(test "xMinYMin slice", *coords).to eq [[80, 80], [0, 0]]
-        expect(test "xMaxYMax slice", *coords).to eq [[80, 80], [-30, 0]]
+      it 'correctly calculates the result' do
+        expect(test('xMidYMid slice', *coords)).to eq [[80, 80], [-15, 0]]
+        expect(test('xMinYMin slice', *coords)).to eq [[80, 80], [0, 0]]
+        expect(test('xMaxYMax slice', *coords)).to eq [[80, 80], [-30, 0]]
       end
     end
 
-    context "with bigger containers than objects" do
-      let(:coords) { [[100,80], [50,50]] }
+    context 'with bigger containers than objects' do
+      let(:coords) { [[100, 80], [50, 50]] }
 
-      it "correctly calculates the result" do
-        expect(test "xMidYMid slice", *coords).to eq [[100, 100], [0, -10]]
-        expect(test "xMinYMin slice", *coords).to eq [[100, 100], [0, 0]]
-        expect(test "xMaxYMax slice", *coords).to eq [[100, 100], [0, -20]]
+      it 'correctly calculates the result' do
+        expect(test('xMidYMid slice', *coords)).to eq [[100, 100], [0, -10]]
+        expect(test('xMinYMin slice', *coords)).to eq [[100, 100], [0, 0]]
+        expect(test('xMaxYMax slice', *coords)).to eq [[100, 100], [0, -20]]
       end
     end
 
-    context "with oddly shaped containers" do
-      let(:coords) { [[100,20], [50,50]] }
+    context 'with oddly shaped containers' do
+      let(:coords) { [[100, 20], [50, 50]] }
 
-      it "correctly calculates the result" do
-        expect(test "xMidYMid slice", *coords).to eq [[100, 100], [0, -40]]
-        expect(test "xMinYMin slice", *coords).to eq [[100, 100], [0, 0]]
-        expect(test "xMaxYMax slice", *coords).to eq [[100, 100], [0, -80]]
+      it 'correctly calculates the result' do
+        expect(test('xMidYMid slice', *coords)).to eq [[100, 100], [0, -40]]
+        expect(test('xMinYMin slice', *coords)).to eq [[100, 100], [0, 0]]
+        expect(test('xMaxYMax slice', *coords)).to eq [[100, 100], [0, -80]]
       end
     end
   end
 
   it "defaults to 'xMidYMid meet' if nothing is supplied" do
-    expect(test "", [50,80], [100,100]).to eq test "xMidYMid meet", [50,80], [100,100]
+    expect(test('', [50, 80], [100, 100])).to eq test 'xMidYMid meet', [50, 80], [100, 100]
   end
 
   it "defaults to 'xMidYMid meet' if something invalid is supplied" do
-    expect(test "completely invalid", [50,80], [100,100]).to eq test "xMidYMid meet", [50,80], [100,100]
+    expect(test('completely invalid', [50, 80], [100, 100])).to eq test 'xMidYMid meet', [50, 80], [100, 100]
   end
 end

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

@@ -1,35 +1,35 @@
-require File.dirname(__FILE__) + '/../../../spec_helper'
+require "#{File.dirname(__FILE__)}/../../../spec_helper"
 
 describe Prawn::SVG::Calculators::DocumentSizing do
   let(:attributes) do
-    {"width" => "150", "height" => "200", "viewBox" => "0 -30 300 800", "preserveAspectRatio" => "xMaxYMid meet"}
+    { 'width' => '150', 'height' => '200', 'viewBox' => '0 -30 300 800', 'preserveAspectRatio' => 'xMaxYMid meet' }
   end
 
   let(:bounds) { [1200, 800] }
 
   let(:sizing) { Prawn::SVG::Calculators::DocumentSizing.new(bounds, attributes) }
 
-  describe "#initialize" do
-    it "takes bounds and a set of attributes and calls set_from_attributes" do
-      expect(sizing.instance_variable_get :@bounds).to eq bounds
-      expect(sizing.instance_variable_get :@document_width).to eq "150"
+  describe '#initialize' do
+    it 'takes bounds and a set of attributes and calls set_from_attributes' do
+      expect(sizing.instance_variable_get(:@bounds)).to eq bounds
+      expect(sizing.instance_variable_get(:@document_width)).to eq '150'
     end
   end
 
-  describe "#set_from_attributes" do
+  describe '#set_from_attributes' do
     let(:sizing) { Prawn::SVG::Calculators::DocumentSizing.new(bounds) }
 
-    it "sets ivars from the passed-in attributes hash" do
+    it 'sets ivars from the passed-in attributes hash' do
       sizing.set_from_attributes(attributes)
-      expect(sizing.instance_variable_get :@document_width).to eq "150"
-      expect(sizing.instance_variable_get :@document_height).to eq "200"
-      expect(sizing.instance_variable_get :@view_box).to eq "0 -30 300 800"
-      expect(sizing.instance_variable_get :@preserve_aspect_ratio).to eq "xMaxYMid meet"
+      expect(sizing.instance_variable_get(:@document_width)).to eq '150'
+      expect(sizing.instance_variable_get(:@document_height)).to eq '200'
+      expect(sizing.instance_variable_get(:@view_box)).to eq '0 -30 300 800'
+      expect(sizing.instance_variable_get(:@preserve_aspect_ratio)).to eq 'xMaxYMid meet'
     end
   end
 
-  describe "#calculate" do
-    it "calculates the document sizing measurements for a given set of inputs" do
+  describe '#calculate' do
+    it 'calculates the document sizing measurements for a given set of inputs' do
       sizing.calculate
       expect(sizing.x_offset).to eq(-75 / 0.25)
       expect(sizing.y_offset).to eq(-30)
@@ -41,7 +41,7 @@ describe Prawn::SVG::Calculators::DocumentSizing do
       expect(sizing.output_height).to eq 200
     end
 
-    it "scales again based on requested width" do
+    it 'scales again based on requested width' do
       sizing.requested_width = 75
       sizing.calculate
       expect(sizing.x_scale).to eq 0.125
@@ -52,7 +52,7 @@ describe Prawn::SVG::Calculators::DocumentSizing do
       expect(sizing.output_height).to eq 100
     end
 
-    it "scales again based on requested height" do
+    it 'scales again based on requested height' do
       sizing.requested_height = 100
       sizing.calculate
       expect(sizing.x_scale).to eq 0.125
@@ -63,18 +63,18 @@ describe Prawn::SVG::Calculators::DocumentSizing do
       expect(sizing.output_height).to eq 100
     end
 
-    it "correctly handles % values being passed in" do
-      sizing.document_width = sizing.document_height = "50%"
+    it 'correctly handles % values being passed in' do
+      sizing.document_width = sizing.document_height = '50%'
       sizing.calculate
       expect(sizing.output_width).to eq 600
       expect(sizing.output_height).to eq 400
     end
 
-    context "when SVG does not specify width and height" do
-      context "when a viewBox is specified" do
-        let(:attributes) { {"viewBox" => "0 0 100 200"} }
+    context 'when SVG does not specify width and height' do
+      context 'when a viewBox is specified' do
+        let(:attributes) { { 'viewBox' => '0 0 100 200' } }
 
-        it "defaults to 100% width and uses the viewbox ratio for height" do
+        it 'defaults to 100% width and uses the viewbox ratio for height' do
           sizing.calculate
           expect(sizing.viewport_width).to eq 100
           expect(sizing.viewport_height).to eq 200
@@ -83,10 +83,10 @@ describe Prawn::SVG::Calculators::DocumentSizing do
         end
       end
 
-      context "when a requested width and height are supplied" do
+      context 'when a requested width and height are supplied' do
         let(:attributes) { {} }
 
-        it "uses the requested width and height" do
+        it 'uses the requested width and height' do
           sizing.requested_width = 550
           sizing.requested_height = 400
           sizing.calculate
@@ -98,10 +98,10 @@ describe Prawn::SVG::Calculators::DocumentSizing do
         end
       end
 
-      context "when a viewBox and a requested width/height are supplied" do
-        let(:attributes) { {"viewBox" => "0 0 100 200"} }
+      context 'when a viewBox and a requested width/height are supplied' do
+        let(:attributes) { { 'viewBox' => '0 0 100 200' } }
 
-        it "uses the requested width and height" do
+        it 'uses the requested width and height' do
           sizing.requested_width = 550
           sizing.requested_height = 400
           sizing.calculate
@@ -113,10 +113,10 @@ describe Prawn::SVG::Calculators::DocumentSizing do
         end
       end
 
-      context "when a viewBox and a requested width is supplied" do
-        let(:attributes) { {"viewBox" => "0 0 100 200"} }
+      context 'when a viewBox and a requested width is supplied' do
+        let(:attributes) { { 'viewBox' => '0 0 100 200' } }
 
-        it "uses the requested width and calculates the height based on the viewBox" do
+        it 'uses the requested width and calculates the height based on the viewBox' do
           sizing.requested_width = 550
           sizing.calculate
 
@@ -127,10 +127,10 @@ describe Prawn::SVG::Calculators::DocumentSizing do
         end
       end
 
-      context "when a viewBox and a requested height is supplied" do
-        let(:attributes) { {"viewBox" => "0 0 100 200"} }
+      context 'when a viewBox and a requested height is supplied' do
+        let(:attributes) { { 'viewBox' => '0 0 100 200' } }
 
-        it "uses the requested height and calculates the width based on the viewBox" do
+        it 'uses the requested height and calculates the width based on the viewBox' do
           sizing.requested_height = 400
           sizing.calculate
 
@@ -141,10 +141,10 @@ describe Prawn::SVG::Calculators::DocumentSizing do
         end
       end
 
-      context "when neither viewBox nor requested width/height specified" do
+      context 'when neither viewBox nor requested width/height specified' do
         let(:attributes) { {} }
 
-        it "defaults to 100%" do
+        it 'defaults to 100%' do
           sizing.calculate
 
           expect(sizing.output_width).to eq 1200

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

@@ -12,7 +12,8 @@ describe Prawn::SVG::Calculators::Pixels do
   end
 
   let(:viewport_sizing) do
-    instance_double(Prawn::SVG::Calculators::DocumentSizing, viewport_width: 600, viewport_height: 400, viewport_diagonal: 500, :requested_width= => nil, :requested_height= => nil)
+    instance_double(Prawn::SVG::Calculators::DocumentSizing, viewport_width: 600, viewport_height: 400,
+      viewport_diagonal: 500, :requested_width= => nil, :requested_height= => nil)
   end
 
   let(:document_sizing) do
@@ -29,49 +30,49 @@ describe Prawn::SVG::Calculators::Pixels do
     allow(subject).to receive(:document).and_return(document)
   end
 
-  describe "#pixels" do
-    it "converts a variety of measurement units to points" do
+  describe '#pixels' do
+    it 'converts a variety of measurement units to points' 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
-      expect(subject.pixels("32pc")).to eq 32.0 * 15
-      expect(subject.pixels("4em")).to eq 4 * 16
-      expect(subject.pixels("4ex")).to eq 4 * 8
-      expect(subject.pixels("32mm")).to be_within(0.0001).of(32 * 72 * 0.0393700787)
-      expect(subject.pixels("32cm")).to be_within(0.0001).of(32 * 72 * 0.393700787)
-      expect(subject.pixels("50%")).to eq 250
+      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
+      expect(subject.pixels('32pc')).to eq 32.0 * 15
+      expect(subject.pixels('4em')).to eq 4 * 16
+      expect(subject.pixels('4ex')).to eq 4 * 8
+      expect(subject.pixels('32mm')).to be_within(0.0001).of(32 * 72 * 0.0393700787)
+      expect(subject.pixels('32cm')).to be_within(0.0001).of(32 * 72 * 0.393700787)
+      expect(subject.pixels('50%')).to eq 250
     end
   end
 
-  describe "#x_pixels" do
-    it "uses the viewport width for percentages" do
-      expect(subject.x_pixels("50")).to eq 50
-      expect(subject.x_pixels("50%")).to eq 300
+  describe '#x_pixels' do
+    it 'uses the viewport width for percentages' do
+      expect(subject.x_pixels('50')).to eq 50
+      expect(subject.x_pixels('50%')).to eq 300
     end
   end
 
-  describe "#y_pixels" do
-    it "uses the viewport height for percentages" do
-      expect(subject.y_pixels("50")).to eq 50
-      expect(subject.y_pixels("50%")).to eq 200
+  describe '#y_pixels' do
+    it 'uses the viewport height for percentages' do
+      expect(subject.y_pixels('50')).to eq 50
+      expect(subject.y_pixels('50%')).to eq 200
     end
   end
 
-  describe "#x" do
-    it "performs the same as #x_pixels" do
-      expect(subject.x("50")).to eq 50
-      expect(subject.x("50%")).to eq 300
+  describe '#x' do
+    it 'performs the same as #x_pixels' do
+      expect(subject.x('50')).to eq 50
+      expect(subject.x('50%')).to eq 300
     end
   end
 
-  describe "#y" do
-    it "performs the same as #y_pixels but subtracts the pixels from the page height" do
-      expect(subject.y("50")).to eq 800 - 50
-      expect(subject.y("50%")).to eq 800 - 200
+  describe '#y' do
+    it 'performs the same as #y_pixels but subtracts the pixels from the page height' do
+      expect(subject.y('50')).to eq 800 - 50
+      expect(subject.y('50%')).to eq 800 - 200
     end
   end
 end

data/spec/prawn/svg/color_spec.rb

@@ -1,70 +1,70 @@
-require File.dirname(__FILE__) + '/../../spec_helper'
+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"
+  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"
+    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"
+    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 == "102030"
-      Prawn::SVG::Color.css_color_to_prawn_color("rgb(-5, 50%, 120%)").should == "007fff"
+    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'
     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 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]
     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 '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'
     end
 
-    it "ignores url()s" do
-      expect(Prawn::SVG::Color.css_color_to_prawn_color("url(#someplace) red")).to eq 'ff0000'
+    it 'ignores url()s' do
+      expect(Prawn::SVG::Color.css_color_to_prawn_color('url(#someplace) red')).to eq 'ff0000'
     end
 
     it "returns black if the color doesn't exist" do
-      expect(Prawn::SVG::Color.css_color_to_prawn_color("blurble")).to eq '000000'
+      expect(Prawn::SVG::Color.css_color_to_prawn_color('blurble')).to eq '000000'
     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
+      expect(Prawn::SVG::Color.css_color_to_prawn_color('url(#someplace)')).to be nil
     end
   end
 
-  describe "::parse" do
-    let(:gradients) { {"flan" => flan_gradient, "drob" => drob_gradient} }
+  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)
+    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")
+        Prawn::SVG::Color::RGB.new('008000'),
+        Prawn::SVG::Color::RGB.new('112233')
       ]
     end
 
     it "appends black to the list if there aren't any url() references" do
-      results = Prawn::SVG::Color.parse("blurble green", gradients, :rgb)
+      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")
+        Prawn::SVG::Color::RGB.new('008000'),
+        Prawn::SVG::Color::RGB.new('000000')
       ]
     end
 
-    it "works in CMYK color mode" do
-      results = Prawn::SVG::Color.parse("blurble green", gradients, :cmyk)
+    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])

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

@@ -1,19 +1,19 @@
 require 'spec_helper'
 
 RSpec.describe Prawn::SVG::CSS::FontFamilyParser do
-  describe "#parse" do
-    it "correctly handles quotes and escaping" do
+  describe '#parse' do
+    it 'correctly handles quotes and escaping' do
       tests = {
-        "" => [],
-        "font" => ["font"],
-        "font name, other font" => ["font name", "other font"],
-        "'font name', other font" => ["font name", "other font"],
-        "'font, name', other font" => ["font, name", "other font"],
-        '"font name", other font' => ["font name", "other font"],
-        '"font, name", other font' => ["font, name", "other font"],
-        'weird \\" name' => ['weird " name'],
-        'weird\\, name' => ["weird, name"],
-        ' stupid , spacing ' => ["stupid", "spacing"],
+        ''                         => [],
+        'font'                     => ['font'],
+        'font name, other font'    => ['font name', 'other font'],
+        "'font name', other font"  => ['font name', 'other font'],
+        "'font, name', other font" => ['font, name', 'other font'],
+        '"font name", other font'  => ['font name', 'other font'],
+        '"font, name", other font' => ['font, name', 'other font'],
+        'weird \\" name'           => ['weird " name'],
+        'weird\\, name'            => ['weird, name'],
+        ' stupid , spacing '       => ['stupid', 'spacing']
       }
 
       tests.each do |string, expected|

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

@@ -1,33 +1,33 @@
 require 'spec_helper'
 
 RSpec.describe Prawn::SVG::CSS::SelectorParser do
-  describe "::parse" do
-    it "parses a simple selector" do
-      expect(described_class.parse("div")).to eq [{name: "div"}]
-      expect(described_class.parse(".c1")).to eq [{class: ["c1"]}]
+  describe '::parse' do
+    it 'parses a simple selector' do
+      expect(described_class.parse('div')).to eq [{ name: 'div' }]
+      expect(described_class.parse('.c1')).to eq [{ class: ['c1'] }]
     end
 
-    it "parses a complex selector" do
-      result = described_class.parse("div#count .c1.c2 > span.large + div~.other:first-child *:nth-child(3)")
+    it 'parses a complex selector' do
+      result = described_class.parse('div#count .c1.c2 > span.large + div~.other:first-child *:nth-child(3)')
       expect(result).to eq [
-        {name: "div", id: ["count"]},
-        {combinator: :descendant, class: ["c1", "c2"]},
-        {combinator: :child, name: "span", class: ["large"]},
-        {combinator: :adjacent, name: "div"},
-        {combinator: :siblings, class: ["other"], pseudo_class: ["first-child"]},
-        {combinator: :descendant, name: "*", pseudo_class: ["nth-child(3)"]},
+        { name: 'div', id: ['count'] },
+        { combinator: :descendant, class: ['c1', 'c2'] },
+        { combinator: :child, name: 'span', class: ['large'] },
+        { combinator: :adjacent, name: 'div' },
+        { combinator: :siblings, class: ['other'], pseudo_class: ['first-child'] },
+        { combinator: :descendant, name: '*', pseudo_class: ['nth-child(3)'] }
       ]
     end
 
-    it "parses attributes" do
-      expect(described_class.parse("[abc]")).to eq [{attribute: [["abc", nil, nil]]}]
-      expect(described_class.parse("[abc=123]")).to eq [{attribute: [["abc", '=', '123']]}]
-      expect(described_class.parse("[abc^=123]")).to eq [{attribute: [["abc", '^=', '123']]}]
-      expect(described_class.parse("[ abc ^= 123 ]")).to eq [{attribute: [["abc", '^=', '123']]}]
-      expect(described_class.parse("[abc^='123']")).to eq [{attribute: [["abc", '^=', '123']]}]
-      expect(described_class.parse("[abc^= '123' ]")).to eq [{attribute: [["abc", '^=', '123']]}]
-      expect(described_class.parse("[abc^= '123\\'456' ]")).to eq [{attribute: [["abc", '^=', '123\'456']]}]
-      expect(described_class.parse('[abc^= "123\\"456" ]')).to eq [{attribute: [["abc", '^=', '123"456']]}]
+    it 'parses attributes' do
+      expect(described_class.parse('[abc]')).to eq [{ attribute: [['abc', nil, nil]] }]
+      expect(described_class.parse('[abc=123]')).to eq [{ attribute: [['abc', '=', '123']] }]
+      expect(described_class.parse('[abc^=123]')).to eq [{ attribute: [['abc', '^=', '123']] }]
+      expect(described_class.parse('[ abc ^= 123 ]')).to eq [{ attribute: [['abc', '^=', '123']] }]
+      expect(described_class.parse("[abc^='123']")).to eq [{ attribute: [['abc', '^=', '123']] }]
+      expect(described_class.parse("[abc^= '123' ]")).to eq [{ attribute: [['abc', '^=', '123']] }]
+      expect(described_class.parse("[abc^= '123\\'456' ]")).to eq [{ attribute: [['abc', '^=', '123\'456']] }]
+      expect(described_class.parse('[abc^= "123\\"456" ]')).to eq [{ attribute: [['abc', '^=', '123"456']] }]
     end
   end
 end