prawn-svg 0.34.1 → 0.35.0

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

@@ -1,45 +1,45 @@
 require 'spec_helper'
 
 RSpec.describe Prawn::SVG::Elements::Polyline do
-  let(:document) { Prawn::SVG::Document.new(svg, [800, 600], {width: 800, height: 600}) }
+  let(:document) { Prawn::SVG::Document.new(svg, [800, 600], { width: 800, height: 600 }) }
 
   subject do
     Prawn::SVG::Elements::Polyline.new(document, document.root, [], Prawn::SVG::State.new)
   end
 
-  context "with a valid points attribute" do
+  context 'with a valid points attribute' do
     let(:svg) { '<polyline points="10 10 20,20 30,30" />' }
 
-    it "renders the polyline" do
+    it 'renders the polyline' do
       subject.process
       expect(subject.base_calls).to eq [
-        ["fill", [], {}, [
-          ["move_to", [[10.0, 590.0]], {}, []],
-          ["line_to", [[20.0, 580.0]], {}, []],
-          ["line_to", [[30.0, 570.0]], {}, []]]
-        ]
+        ['fill', [], {}, [
+          ['move_to', [[10.0, 590.0]], {}, []],
+          ['line_to', [[20.0, 580.0]], {}, []],
+          ['line_to', [[30.0, 570.0]], {}, []]
+        ]]
       ]
     end
   end
 
-  context "with a polyline that has an odd number of arguments" do
+  context 'with a polyline that has an odd number of arguments' do
     let(:svg) { '<polyline points="10 10 20,20 30" />' }
 
-    it "ignores the last one" do
+    it 'ignores the last one' do
       subject.process
       expect(subject.base_calls).to eq [
-        ["fill", [], {}, [
-          ["move_to", [[10.0, 590.0]], {}, []],
-          ["line_to", [[20.0, 580.0]], {}, []]]
-        ]
+        ['fill', [], {}, [
+          ['move_to', [[10.0, 590.0]], {}, []],
+          ['line_to', [[20.0, 580.0]], {}, []]
+        ]]
       ]
     end
   end
 
-  context "with a polyline that has no arguments" do
+  context 'with a polyline that has no arguments' do
     let(:svg) { '<polyline points="" />' }
 
-    it "renders nothing" do
+    it 'renders nothing' do
       subject.process
       expect(subject.base_calls).to eq []
     end

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

@@ -1,152 +1,162 @@
-require File.dirname(__FILE__) + '/../../../spec_helper'
+require "#{File.dirname(__FILE__)}/../../../spec_helper"
 
 describe Prawn::SVG::Elements::Text do
-  let(:document) { Prawn::SVG::Document.new(svg, [800, 600], {}, font_registry: Prawn::SVG::FontRegistry.new("Helvetica" => {:normal => nil}, "Courier" => {normal: nil}, 'Times-Roman' => {normal: nil})) }
-  let(:element)  { Prawn::SVG::Elements::Text.new(document, document.root, [], fake_state) }
+  let(:document) do
+    Prawn::SVG::Document.new(svg, [800, 600], {},
+      font_registry: Prawn::SVG::FontRegistry.new('Helvetica' => { normal: nil }, 'Courier' => { normal: nil }, 'Times-Roman' => { normal: nil }))
+  end
+  let(:element) { Prawn::SVG::Elements::Text.new(document, document.root, [], fake_state) }
 
-  let(:default_style) { {:size=>16, :style=>:normal, :text_anchor=>'start', :at=>[:relative, :relative], :offset=>[0,0]} }
+  let(:default_style) do
+    { size: 16, style: :normal, text_anchor: 'start', at: [:relative, :relative], offset: [0, 0] }
+  end
 
-  describe "xml:space preserve" do
+  describe 'xml:space preserve' do
     let(:svg) { %(<text#{attributes}>some\n\t  text</text>) }
 
-    context "when xml:space is preserve" do
+    context 'when xml:space is preserve' do
       let(:attributes) { ' xml:space="preserve"' }
 
-      it "converts newlines and tabs to spaces, and preserves spaces" do
+      it 'converts newlines and tabs to spaces, and preserves spaces' do
         element.process
 
-        expect(flatten_calls(element.calls)).to include ["draw_text", ["some    text"], {:size=>16, :style=>:normal, :text_anchor=>'start', :at=>[:relative, :relative], :offset=>[0,0]}]
+        expect(flatten_calls(element.calls)).to include ['draw_text', ['some    text'],
+                                                         { size: 16, style: :normal, text_anchor: 'start', at: [:relative, :relative], offset: [0, 0] }]
       end
     end
 
-    context "when xml:space is unspecified" do
+    context 'when xml:space is unspecified' do
       let(:attributes) { '' }
 
-      it "strips space" do
+      it 'strips space' do
         element.process
 
-        expect(flatten_calls(element.calls)).to include ["draw_text", ["some text"], {:size=>16, :style=>:normal, :text_anchor=>'start', :at=>[:relative, :relative], :offset=>[0,0]}]
+        expect(flatten_calls(element.calls)).to include ['draw_text', ['some text'],
+                                                         { size: 16, style: :normal, text_anchor: 'start', at: [:relative, :relative], offset: [0, 0] }]
       end
     end
   end
 
-  describe "conventional whitespace handling" do
+  describe 'conventional whitespace handling' do
     let(:svg) do
-      <<-SVG
-<text>
-  <tspan>
-  </tspan>
-  Some text here
-  <tspan>More text</tspan>
-Even more
-<tspan></tspan>
-<tspan>
-  leading goodness
-  </tspan>
-  ok
-      <tspan>
-      </tspan>
-</text>
+      <<~SVG
+        <text>
+          <tspan>
+          </tspan>
+          Some text here
+          <tspan>More text</tspan>
+        Even more
+        <tspan></tspan>
+        <tspan>
+          leading goodness
+          </tspan>
+          ok
+              <tspan>
+              </tspan>
+        </text>
       SVG
     end
 
-    it "correctly apportions white space between the tags" do
+    it 'correctly apportions white space between the tags' do
       element.process
       calls = element.calls.flatten
-      expect(calls).to include "Some text here "
-      expect(calls).to include "More text"
-      expect(calls).to include "Even more"
-      expect(calls).to include " leading goodness "
-      expect(calls).to include "ok"
+      expect(calls).to include 'Some text here '
+      expect(calls).to include 'More text'
+      expect(calls).to include 'Even more'
+      expect(calls).to include ' leading goodness '
+      expect(calls).to include 'ok'
     end
   end
 
-  describe "when text-anchor is specified" do
+  describe 'when text-anchor is specified' do
     let(:svg) { '<g text-anchor="middle" font-size="12"><text x="50" y="14">Text</text></g>' }
     let(:element) { Prawn::SVG::Elements::Container.new(document, document.root, [], fake_state) }
 
-    it "should inherit text-anchor from parent element" do
+    it 'should inherit text-anchor from parent element' do
       element.process
-      expect(element.calls.flatten).to include(:size => 12.0, :style => :normal, :text_anchor => "middle", :at => [50.0, 586.0], :offset => [0,0])
+      expect(element.calls.flatten).to include(size: 12.0, style: :normal, text_anchor: 'middle',
+        at: [50.0, 586.0], offset: [0, 0])
     end
   end
 
-  describe "letter-spacing" do
+  describe 'letter-spacing' do
     let(:svg) { '<text letter-spacing="5">spaced</text>' }
 
-    it "calls character_spacing with the requested size" do
+    it 'calls character_spacing with the requested size' do
       element.process
 
       expect(element.base_calls).to eq [
-        ["text_group", [], {}, [
-          ["font", ["Helvetica"], {style: :normal}, []],
-          ["character_spacing", [5.0], {}, [
-            ["draw_text", ["spaced"], default_style, []]
+        ['text_group', [], {}, [
+          ['font', ['Helvetica'], { style: :normal }, []],
+          ['character_spacing', [5.0], {}, [
+            ['draw_text', ['spaced'], default_style, []]
           ]]
         ]]
       ]
     end
   end
 
-  describe "underline" do
+  describe 'underline' do
     let(:svg) { '<text text-decoration="underline">underlined</text>' }
 
-    it "marks the element to be underlined" do
+    it 'marks the element to be underlined' do
       element.process
 
       expect(element.base_calls).to eq [
-        ["text_group", [], {},[
-          ["font", ["Helvetica"], {:style=>:normal}, []],
-          ["draw_text", ["underlined"], default_style.merge(decoration: 'underline'), []]
+        ['text_group', [], {}, [
+          ['font', ['Helvetica'], { style: :normal }, []],
+          ['draw_text', ['underlined'], default_style.merge(decoration: 'underline'), []]
         ]]
       ]
     end
   end
 
-  describe "fill/stroke modes" do
-    context "with a stroke and no fill" do
+  describe 'fill/stroke modes' do
+    context 'with a stroke and no fill' do
       let(:svg) { '<text stroke="red" fill="none">stroked</text>' }
 
-      it "calls text_rendering_mode with the requested options" do
+      it 'calls text_rendering_mode with the requested options' do
         element.process
 
         expect(element.base_calls).to eq [
-          ["text_group", [], {}, [
-            ["stroke_color", ["ff0000"], {}, []],
-            ["font", ["Helvetica"], {style: :normal}, []],
-            ["text_rendering_mode", [:stroke], {}, [
-              ["draw_text", ["stroked"], default_style, []]
+          ['text_group', [], {}, [
+            ['stroke_color', ['ff0000'], {}, []],
+            ['font', ['Helvetica'], { style: :normal }, []],
+            ['text_rendering_mode', [:stroke], {}, [
+              ['draw_text', ['stroked'], default_style, []]
             ]]
           ]]
         ]
       end
     end
 
-    context "with a mixture of everything" do
-      let(:svg) { '<text stroke="red" fill="none">stroked <tspan fill="black">both</tspan><tspan stroke="none">neither</tspan></text>' }
+    context 'with a mixture of everything' do
+      let(:svg) do
+        '<text stroke="red" fill="none">stroked <tspan fill="black">both</tspan><tspan stroke="none">neither</tspan></text>'
+      end
 
-      it "calls text_rendering_mode with the requested options" do
+      it 'calls text_rendering_mode with the requested options' do
         element.process
 
         expect(element.base_calls).to eq [
-          ["text_group", [], {}, [
-            ["stroke_color", ["ff0000"], {}, []],
-            ["font", ["Helvetica"], {style: :normal}, []],
-            ["text_rendering_mode", [:stroke], {}, [
-              ["draw_text", ["stroked "], default_style, []],
-              ["save", [], {}, []],
-              ["fill_color", ["000000"], {}, []],
-              ["font", ["Helvetica"], {style: :normal}, []],
-              ["text_rendering_mode", [:fill_stroke], {}, [
-                ["draw_text", ["both"], default_style, []]
+          ['text_group', [], {}, [
+            ['stroke_color', ['ff0000'], {}, []],
+            ['font', ['Helvetica'], { style: :normal }, []],
+            ['text_rendering_mode', [:stroke], {}, [
+              ['draw_text', ['stroked '], default_style, []],
+              ['save', [], {}, []],
+              ['fill_color', ['000000'], {}, []],
+              ['font', ['Helvetica'], { style: :normal }, []],
+              ['text_rendering_mode', [:fill_stroke], {}, [
+                ['draw_text', ['both'], default_style, []]
               ]],
-              ["restore", [], {}, []],
-              ["save", [], {}, []],
-              ["font", ["Helvetica"], {style: :normal}, []],
-              ["text_rendering_mode", [:invisible], {}, [
-                ["draw_text", ["neither"], default_style, []]
+              ['restore', [], {}, []],
+              ['save', [], {}, []],
+              ['font', ['Helvetica'], { style: :normal }, []],
+              ['text_rendering_mode', [:invisible], {}, [
+                ['draw_text', ['neither'], default_style, []]
               ]],
-              ["restore", [], {}, []],
+              ['restore', [], {}, []]
             ]]
           ]]
         ]
@@ -154,86 +164,98 @@ Even more
     end
   end
 
-  describe "font finding" do
-    context "with a font that exists" do
+  describe 'font finding' do
+    context 'with a font that exists' do
       let(:svg) { '<text font-family="monospace">hello</text>' }
 
-      it "finds the font and uses it" do
+      it 'finds the font and uses it' do
         element.process
-        expect(flatten_calls(element.base_calls)).to include ['font', ['Courier'], {style: :normal}]
+        expect(flatten_calls(element.base_calls)).to include ['font', ['Courier'], { style: :normal }]
       end
     end
 
     context "with a font that doesn't exist" do
       let(:svg) { '<text font-family="does not exist">hello</text>' }
 
-      it "uses the fallback font" do
+      it 'uses the fallback font' do
         element.process
-        expect(flatten_calls(element.base_calls)).to include ['font', ['Times-Roman'], {style: :normal}]
+        expect(flatten_calls(element.base_calls)).to include ['font', ['Times-Roman'], { style: :normal }]
       end
 
-      context "when there is no fallback font" do
-        before { document.font_registry.installed_fonts.delete("Times-Roman") }
+      context 'when there is no fallback font' do
+        before { document.font_registry.installed_fonts.delete('Times-Roman') }
 
         it "doesn't call the font method and logs a warning" do
           element.process
           expect(element.base_calls.flatten).to_not include 'font'
-          expect(document.warnings.first).to include "is not a known font"
+          expect(document.warnings.first).to include 'is not a known font'
         end
       end
     end
   end
 
-  describe "<tref>" do
+  describe '<tref>' do
     let(:svg) { '<svg xmlns:xlink="http://www.w3.org/1999/xlink"><defs><text id="ref" fill="green">my reference text</text></defs><text x="10"><tref xlink:href="#ref" fill="red" /></text></svg>' }
     let(:element) { Prawn::SVG::Elements::Root.new(document, document.root, [], fake_state) }
 
-    it "references the text" do
+    it 'references the text' do
       element.process
       expect(flatten_calls(element.base_calls)[9..11]).to eq [
-        ["fill_color", ["ff0000"], {}],
-        ["font", ["Helvetica"], {:style=>:normal}],
-        ["draw_text", ["my reference text"], {:size=>16, :style=>:normal, :text_anchor=>"start", :at=>[10.0, :relative], :offset=>[0,0]}],
+        ['fill_color', ['ff0000'], {}],
+        ['font', ['Helvetica'], { style: :normal }],
+        ['draw_text', ['my reference text'],
+         { size: 16, style: :normal, text_anchor: 'start', at: [10.0, :relative], offset: [0, 0] }]
       ]
     end
   end
 
-  describe "dx and dy attributes" do
+  describe 'dx and dy attributes' do
     let(:svg) { '<text x="10 20" dx="30 50 80" dy="2">Hi there, this is a good test</text>' }
 
-    it "correctly calculates the positions of the text" do
+    it 'correctly calculates the positions of the text' do
       element.process
 
       expect(flatten_calls(element.base_calls)).to eq [
-        ["text_group", [], {}],
-        ["font", ["Helvetica"], {:style=>:normal}],
-        ["draw_text", ["H"], {:size=>16, :style=>:normal, :text_anchor=>"start", :at=>[10.0, :relative], :offset=>[30.0, 2.0]}],
-        ["draw_text", ["i"], {:size=>16, :style=>:normal, :text_anchor=>"start", :at=>[20.0, :relative], :offset=>[50.0, 0]}],
-        ["draw_text", [" there, this is a good test"], {:size=>16, :style=>:normal, :text_anchor=>"start", :at=>[:relative, :relative], :offset=>[80.0, 0]}]
+        ['text_group', [], {}],
+        ['font', ['Helvetica'], { style: :normal }],
+        ['draw_text', ['H'],
+         { size: 16, style: :normal, text_anchor: 'start', at: [10.0, :relative], offset: [30.0, 2.0] }],
+        ['draw_text', ['i'],
+         { size: 16, style: :normal, text_anchor: 'start', at: [20.0, :relative], offset: [50.0, 0] }],
+        ['draw_text', [' there, this is a good test'],
+         { size: 16, style: :normal, text_anchor: 'start', at: [:relative, :relative], offset: [80.0, 0] }]
       ]
     end
   end
 
-  describe "rotate attribute" do
+  describe 'rotate attribute' do
     let(:svg) { '<text rotate="10 20 30 40 50 60 70 80 90 100">Hi <tspan rotate="0">this</tspan> ok!</text>' }
 
-    it "correctly calculates the positions of the text" do
+    it 'correctly calculates the positions of the text' do
       element.process
 
       expect(flatten_calls(element.base_calls)).to eq [
-        ["text_group", [], {}],
-        ["font", ["Helvetica"], {:style=>:normal}],
-        ["draw_text", ["H"], {:size=>16, :style=>:normal, :text_anchor=>"start", :at=>[:relative, :relative], :offset=>[0, 0], :rotate=>-10.0}],
-        ["draw_text", ["i"], {:size=>16, :style=>:normal, :text_anchor=>"start", :at=>[:relative, :relative], :offset=>[0, 0], :rotate=>-20.0}],
-        ["draw_text", [" "], {:size=>16, :style=>:normal, :text_anchor=>"start", :at=>[:relative, :relative], :offset=>[0, 0], :rotate=>-30.0}],
-        ["save", [], {}],
-        ["font", ["Helvetica"], {:style=>:normal}],
-        ["draw_text", ["this"], {:size=>16, :style=>:normal, :text_anchor=>"start", :at=>[:relative, :relative], :offset=>[0, 0]}],
-        ["restore", [], {}],
-        ["draw_text", [" "], {:size=>16, :style=>:normal, :text_anchor=>"start", :at=>[:relative, :relative], :offset=>[0, 0], :rotate=>-80.0}],
-        ["draw_text", ["o"], {:size=>16, :style=>:normal, :text_anchor=>"start", :at=>[:relative, :relative], :offset=>[0, 0], :rotate=>-90.0}],
-        ["draw_text", ["k"], {:size=>16, :style=>:normal, :text_anchor=>"start", :at=>[:relative, :relative], :offset=>[0, 0], :rotate=>-100.0}],
-        ["draw_text", ["!"], {:size=>16, :style=>:normal, :text_anchor=>"start", :at=>[:relative, :relative], :offset=>[0, 0], :rotate=>-100.0}]
+        ['text_group', [], {}],
+        ['font', ['Helvetica'], { style: :normal }],
+        ['draw_text', ['H'],
+         { size: 16, style: :normal, text_anchor: 'start', at: [:relative, :relative], offset: [0, 0], rotate: -10.0 }],
+        ['draw_text', ['i'],
+         { size: 16, style: :normal, text_anchor: 'start', at: [:relative, :relative], offset: [0, 0], rotate: -20.0 }],
+        ['draw_text', [' '],
+         { size: 16, style: :normal, text_anchor: 'start', at: [:relative, :relative], offset: [0, 0], rotate: -30.0 }],
+        ['save', [], {}],
+        ['font', ['Helvetica'], { style: :normal }],
+        ['draw_text', ['this'],
+         { size: 16, style: :normal, text_anchor: 'start', at: [:relative, :relative], offset: [0, 0] }],
+        ['restore', [], {}],
+        ['draw_text', [' '],
+         { size: 16, style: :normal, text_anchor: 'start', at: [:relative, :relative], offset: [0, 0], rotate: -80.0 }],
+        ['draw_text', ['o'],
+         { size: 16, style: :normal, text_anchor: 'start', at: [:relative, :relative], offset: [0, 0], rotate: -90.0 }],
+        ['draw_text', ['k'],
+         { size: 16, style: :normal, text_anchor: 'start', at: [:relative, :relative], offset: [0, 0], rotate: -100.0 }],
+        ['draw_text', ['!'],
+         { size: 16, style: :normal, text_anchor: 'start', at: [:relative, :relative], offset: [0, 0], rotate: -100.0 }]
       ]
     end
   end
@@ -241,26 +263,26 @@ Even more
   describe "when there's a comment inside the text element" do
     let(:svg) { '<text>Hi <!-- comment --> there</text>' }
 
-    it "ignores the comment" do
+    it 'ignores the comment' do
       element.process
 
       expect(flatten_calls(element.calls)).to eq [
-        ["text_group", [], {}],
-        ["font", ["Helvetica"], {:style=>:normal}],
-        ["draw_text",
-          ["Hi "],
-          {:size=>16,
-            :style=>:normal,
-            :text_anchor=>"start",
-            :at=>[:relative, :relative],
-            :offset=>[0, 0]}],
-        ["draw_text",
-          ["there"],
-          {:size=>16,
-            :style=>:normal,
-            :text_anchor=>"start",
-            :at=>[:relative, :relative],
-            :offset=>[0, 0]}]
+        ['text_group', [], {}],
+        ['font', ['Helvetica'], { style: :normal }],
+        ['draw_text',
+         ['Hi '],
+         { size:        16,
+           style:       :normal,
+           text_anchor: 'start',
+           at:          [:relative, :relative],
+           offset:      [0, 0] }],
+        ['draw_text',
+         ['there'],
+         { size:        16,
+           style:       :normal,
+           text_anchor: 'start',
+           at:          [:relative, :relative],
+           offset:      [0, 0] }]
       ]
     end
   end

data/spec/prawn/svg/font_registry_spec.rb

@@ -1,84 +1,84 @@
 require 'spec_helper'
 
 RSpec.describe Prawn::SVG::FontRegistry do
-  describe "#load" do
+  describe '#load' do
     let(:pdf) { Prawn::Document.new }
     let(:font_registry) { Prawn::SVG::FontRegistry.new(pdf.font_families) }
 
-    it "matches a built in font" do
+    it 'matches a built in font' do
       font_registry.load("blah, 'courier', nothing").name.should == 'Courier'
     end
 
-    it "matches a default font" do
-      font_registry.load("serif").name.should == 'Times-Roman'
-      font_registry.load("blah, serif").name.should == 'Times-Roman'
-      font_registry.load("blah, serif , test").name.should == 'Times-Roman'
+    it 'matches a default font' do
+      font_registry.load('serif').name.should
+      font_registry.load('blah, serif').name.should
+      font_registry.load('blah, serif , test').name.should == 'Times-Roman'
     end
 
-    if Prawn::SVG::FontRegistry.new({}).installed_fonts["Verdana"]
-      it "matches a font installed on the system" do
-        font_registry.load("verdana, sans-serif").name.should == 'Verdana'
-        font_registry.load("VERDANA, sans-serif").name.should == 'Verdana'
-        font_registry.load("something, \"Times New Roman\", serif").name.should == "Times New Roman"
-        font_registry.load("something, Times New Roman, serif").name.should == "Times New Roman"
+    if Prawn::SVG::FontRegistry.new({}).installed_fonts['Verdana']
+      it 'matches a font installed on the system' do
+        font_registry.load('verdana, sans-serif').name.should
+        font_registry.load('VERDANA, sans-serif').name.should
+        font_registry.load('something, "Times New Roman", serif').name.should
+        font_registry.load('something, Times New Roman, serif').name.should == 'Times New Roman'
       end
     else
       it "not running font test because we couldn't find Verdana installed on the system"
     end
 
     it "returns nil if it can't find any such font" do
-      font_registry.load("blah, thing").should be_nil
-      font_registry.load("").should be_nil
+      font_registry.load('blah, thing').should be_nil
+      font_registry.load('').should be_nil
     end
   end
 
-  describe "#installed_fonts" do
-    let(:ttf)  { instance_double(Prawn::SVG::TTF, family: "Awesome Font", subfamily: "Italic") }
-    let(:ttf2) { instance_double(Prawn::SVG::TTF, family: "Awesome Font", subfamily: "Regular") }
+  describe '#installed_fonts' do
+    let(:ttf)  { instance_double(Prawn::SVG::TTF, family: 'Awesome Font', subfamily: 'Italic') }
+    let(:ttf2) { instance_double(Prawn::SVG::TTF, family: 'Awesome Font', subfamily: 'Regular') }
     before { Prawn::SVG::FontRegistry.external_font_families.clear }
 
     let(:pdf) do
       doc = Prawn::Document.new
       doc.font_families.update({
-        "Awesome Font" => {:italic => "second.ttf", :normal => "file.ttf"}
+        'Awesome Font' => { italic: 'second.ttf', normal: 'file.ttf' }
       })
       doc
     end
 
     let(:font_registry) { Prawn::SVG::FontRegistry.new(pdf.font_families) }
 
-    it "does not override existing entries in pdf when loading external fonts" do
-      expect(Prawn::SVG::FontRegistry).to receive(:font_path).and_return(["x"])
-      expect(Dir).to receive(:[]).with("x/**/*").and_return(["file.ttf", "second.ttf"])
-      expect(Prawn::SVG::TTF).to receive(:new).with("file.ttf").and_return(ttf)
-      expect(Prawn::SVG::TTF).to receive(:new).with("second.ttf").and_return(ttf2)
+    it 'does not override existing entries in pdf when loading external fonts' do
+      expect(Prawn::SVG::FontRegistry).to receive(:font_path).and_return(['x'])
+      expect(Dir).to receive(:[]).with('x/**/*').and_return(['file.ttf', 'second.ttf'])
+      expect(Prawn::SVG::TTF).to receive(:new).with('file.ttf').and_return(ttf)
+      expect(Prawn::SVG::TTF).to receive(:new).with('second.ttf').and_return(ttf2)
       expect(File).to receive(:file?).at_least(:once).and_return(true)
 
       Prawn::SVG::FontRegistry.load_external_fonts
       font_registry.installed_fonts
 
-      existing_font = font_registry.installed_fonts["Awesome Font"]
-      expect(existing_font).to eq(:italic => "second.ttf",:normal => "file.ttf")
+      existing_font = font_registry.installed_fonts['Awesome Font']
+      expect(existing_font).to eq(italic: 'second.ttf', normal: 'file.ttf')
     end
   end
 
-  describe "::load_external_fonts" do
-    let(:ttf)  { instance_double(Prawn::SVG::TTF, family: "Awesome Font", subfamily: "Italic") }
-    let(:ttf2) { instance_double(Prawn::SVG::TTF, family: "Awesome Font", subfamily: "Regular") }
+  describe '::load_external_fonts' do
+    let(:ttf)  { instance_double(Prawn::SVG::TTF, family: 'Awesome Font', subfamily: 'Italic') }
+    let(:ttf2) { instance_double(Prawn::SVG::TTF, family: 'Awesome Font', subfamily: 'Regular') }
 
     before { Prawn::SVG::FontRegistry.external_font_families.clear }
 
-    it "scans the font path and loads in some fonts" do
-      expect(Prawn::SVG::FontRegistry).to receive(:font_path).and_return(["x"])
-      expect(Dir).to receive(:[]).with("x/**/*").and_return(["file.ttf", "second.ttf"])
-      expect(Prawn::SVG::TTF).to receive(:new).with("file.ttf").and_return(ttf)
-      expect(Prawn::SVG::TTF).to receive(:new).with("second.ttf").and_return(ttf2)
+    it 'scans the font path and loads in some fonts' do
+      expect(Prawn::SVG::FontRegistry).to receive(:font_path).and_return(['x'])
+      expect(Dir).to receive(:[]).with('x/**/*').and_return(['file.ttf', 'second.ttf'])
+      expect(Prawn::SVG::TTF).to receive(:new).with('file.ttf').and_return(ttf)
+      expect(Prawn::SVG::TTF).to receive(:new).with('second.ttf').and_return(ttf2)
       expect(File).to receive(:file?).at_least(:once).and_return(true)
 
       Prawn::SVG::FontRegistry.load_external_fonts
 
       result = Prawn::SVG::FontRegistry.external_font_families
-      expect(result).to eq("Awesome Font" => {:italic => "file.ttf", :normal => "second.ttf"})
+      expect(result).to eq('Awesome Font' => { italic: 'file.ttf', normal: 'second.ttf' })
     end
   end
 end

data/spec/prawn/svg/font_spec.rb

@@ -1,14 +1,14 @@
-require File.dirname(__FILE__) + '/../../spec_helper'
+require "#{File.dirname(__FILE__)}/../../spec_helper"
 
 describe Prawn::SVG::Font do
-  describe "#initialize" do
-    it "maps generic font name to built-in font" do
+  describe '#initialize' do
+    it 'maps generic font name to built-in font' do
       font_registry = Prawn::SVG::FontRegistry.new({})
       font = Prawn::SVG::Font.new('sans-serif', :normal, :normal, font_registry: font_registry)
       font.name.should == 'Helvetica'
     end
 
-    it "preserves generic font name if mapped" do
+    it 'preserves generic font name if mapped' do
       font_registry = Prawn::SVG::FontRegistry.new('sans-serif' => { normal: 'Times-Roman' })
       font = Prawn::SVG::Font.new('sans-serif', :normal, :normal, font_registry: font_registry)
       font.name.should == 'sans-serif'