prawn-svg 0.34.2 → 0.35.1

data/spec/prawn/svg/interface_spec.rb

@@ -5,66 +5,74 @@ describe Prawn::SVG::Interface do
   let(:prawn)  { instance_double(Prawn::Document, font_families: {}, bounds: bounds, cursor: 600) }
   let(:svg)    { '<svg width="250" height="100"></svg>' }
 
-  describe "#initialize" do
-    describe "invalid option detection" do
-      it "rejects invalid options when debug is on" do
+  describe '#initialize' do
+    describe 'invalid option detection' do
+      it 'rejects invalid options when debug is on' do
         allow(Prawn).to receive(:debug).and_return(true)
 
-        expect {
-          Prawn::SVG::Interface.new(svg, prawn, :invalid => "option")
-        }.to raise_error(Prawn::Errors::UnknownOption)
+        expect do
+          Prawn::SVG::Interface.new(svg, prawn, invalid: 'option')
+        end.to raise_error(Prawn::Errors::UnknownOption)
       end
 
-      it "does nothing if an invalid option is given and debug is off" do
-        Prawn::SVG::Interface.new(svg, prawn, :invalid => "option")
+      it 'does nothing if an invalid option is given and debug is off' do
+        Prawn::SVG::Interface.new(svg, prawn, invalid: 'option')
       end
     end
   end
 
-  describe "#draw" do
-    context "when the sizing object indicates the sizes are invalid" do
+  describe '#draw' do
+    context 'when the sizing object indicates the sizes are invalid' do
       let(:interface) { Prawn::SVG::Interface.new('<svg width="0"></svg>', prawn, {}) }
 
       it "doesn't draw anything and adds a warning" do
         interface.draw
-        expect(interface.document.warnings).to eq ["Zero or negative sizing data means this SVG cannot be rendered"]
+        expect(interface.document.warnings).to eq ['Zero or negative sizing data means this SVG cannot be rendered']
       end
     end
 
-    describe "rewrites" do
+    describe 'rewrites' do
       before do
         [:save_font, :bounding_box].each { |message| allow(prawn).to receive(message).and_yield }
-        allow(prawn).to receive_messages([:move_to, :line_to, :close_path, :fill_color, :stroke_color, :transformation_matrix, :restore_graphics_state])
-        allow(prawn).to receive(:save_graphics_state) { |&block| block.call if block }
+        allow(prawn).to receive_messages([:move_to, :line_to, :close_path, :fill_color, :stroke_color,
+                                          :transformation_matrix, :restore_graphics_state])
+        allow(prawn).to receive(:save_graphics_state) { |&block| block&.call }
       end
 
-      context "when fill_and_stroke is issued" do
+      context 'when fill_and_stroke is issued' do
         def expect_rectangle
-          if RUBY_VERSION.start_with?("2.7.")
+          if RUBY_VERSION.start_with?('2.7.')
             expect(prawn).to receive(:rectangle)
           else
             expect(prawn).to receive(:rectangle).with([0, 100], 10, 10)
           end
         end
 
-        context "and fill rule is not set" do
-          let(:interface) { Prawn::SVG::Interface.new('<svg width="250" height="100"><rect width="10" height="10" stroke="red"></rect></svg>', prawn, {}) }
+        context 'and fill rule is not set' do
+          let(:interface) do
+            Prawn::SVG::Interface.new('<svg width="250" height="100"><rect width="10" height="10" stroke="red"></rect></svg>',
+              prawn, {})
+          end
 
           it "adds content 'B'" do
             expect_rectangle
-            expect(prawn).to receive(:add_content).with("W n")
-            expect(prawn).to receive(:add_content).with("B")
+            expect(prawn).to receive(:add_content).with('W n')
+            expect(prawn).to receive(:add_content).with('B')
             interface.draw
           end
         end
 
-        context "and fill rule is evenodd" do
-          let(:interface) { Prawn::SVG::Interface.new('<svg width="250" height="100"><rect width="10" height="10" stroke="red" fill-rule="evenodd"></rect></svg>', prawn, {}) }
+        context 'and fill rule is evenodd' do
+          let(:interface) do
+            Prawn::SVG::Interface.new(
+              '<svg width="250" height="100"><rect width="10" height="10" stroke="red" fill-rule="evenodd"></rect></svg>', prawn, {}
+            )
+          end
 
           it "adds content 'B*'" do
             expect_rectangle
-            expect(prawn).to receive(:add_content).with("W n")
-            expect(prawn).to receive(:add_content).with("B*")
+            expect(prawn).to receive(:add_content).with('W n')
+            expect(prawn).to receive(:add_content).with('B*')
             interface.draw
           end
         end
@@ -72,70 +80,70 @@ describe Prawn::SVG::Interface do
     end
   end
 
-  describe "#position" do
+  describe '#position' do
     subject { interface.position }
 
-    context "when options[:at] supplied" do
+    context 'when options[:at] supplied' do
       let(:interface) { Prawn::SVG::Interface.new(svg, prawn, at: [1, 2], position: :left) }
 
-      it "returns options[:at]" do
+      it 'returns options[:at]' do
         expect(subject).to eq [1, 2]
       end
     end
 
-    context "when only a position is supplied" do
+    context 'when only a position is supplied' do
       let(:interface) { Prawn::SVG::Interface.new(svg, prawn, position: position) }
 
-      context "(:left)" do
+      context '(:left)' do
         let(:position) { :left }
         it { is_expected.to eq [0, 600] }
       end
 
-      context "(:center)" do
+      context '(:center)' do
         let(:position) { :center }
         it { is_expected.to eq [275, 600] }
       end
 
-      context "(:right)" do
+      context '(:right)' do
         let(:position) { :right }
         it { is_expected.to eq [550, 600] }
       end
 
-      context "a number" do
+      context 'a number' do
         let(:position) { 25.5 }
         it { is_expected.to eq [25.5, 600] }
       end
     end
 
-    context "when a vposition is supplied" do
+    context 'when a vposition is supplied' do
       let(:interface) { Prawn::SVG::Interface.new(svg, prawn, vposition: vposition) }
 
-      context "(:top)" do
+      context '(:top)' do
         let(:vposition) { :top }
         it { is_expected.to eq [0, 600] }
       end
 
-      context "(:center)" do
+      context '(:center)' do
         let(:vposition) { :center }
         it { is_expected.to eq [0, 350] }
       end
 
-      context "(:bottom)" do
+      context '(:bottom)' do
         let(:vposition) { :bottom }
         it { is_expected.to eq [0, 100] }
       end
 
-      context "a number" do
+      context 'a number' do
         let(:vposition) { 25.5 }
         it { is_expected.to eq [0, 600 - 25.5] }
       end
     end
   end
 
-  describe "#sizing and #resize" do
+  describe '#sizing and #resize' do
     let(:interface) { Prawn::SVG::Interface.new(svg, prawn, {}) }
 
-    it "allows the advanced user to resize the SVG after learning about its dimensions" do
+    it 'allows the advanced user to resize the SVG after learning about its dimensions' do
       expect(interface.sizing.output_width).to eq 250
       expect(interface.sizing.output_height).to eq 100
 

data/spec/prawn/svg/loaders/data_spec.rb

@@ -5,58 +5,58 @@ RSpec.describe Prawn::SVG::Loaders::Data do
 
   subject { Prawn::SVG::Loaders::Data.new.from_url(url) }
 
-  context "with a valid image/png data URL" do
-    let(:url) { "data:image/png;base64,aGVsbG8=" }
+  context 'with a valid image/png data URL' do
+    let(:url) { 'data:image/png;base64,aGVsbG8=' }
 
-    it "loads the data" do
-      expect(subject).to eq "hello"
+    it 'loads the data' do
+      expect(subject).to eq 'hello'
     end
   end
 
-  context "with a valid image/jpeg data URL" do
-    let(:url) { "data:image/jpeg;base64,aGVsbG8=" }
+  context 'with a valid image/jpeg data URL' do
+    let(:url) { 'data:image/jpeg;base64,aGVsbG8=' }
 
-    it "loads the data" do
-      expect(subject).to eq "hello"
+    it 'loads the data' do
+      expect(subject).to eq 'hello'
     end
   end
 
-  context "with a data URL that has extra metadata" do
-    let(:url) { "data:image/png;base64;metadata;here,aGVsbG8=" }
+  context 'with a data URL that has extra metadata' do
+    let(:url) { 'data:image/png;base64;metadata;here,aGVsbG8=' }
 
-    it "loads the data" do
-      expect(subject).to eq "hello"
+    it 'loads the data' do
+      expect(subject).to eq 'hello'
     end
   end
 
   context "with a data URL that's uppercase" do
-    let(:url) { "DATA:IMAGE/PNG;BASE64;METADATA;HERE,aGVsbG8=" }
+    let(:url) { 'DATA:IMAGE/PNG;BASE64;METADATA;HERE,aGVsbG8=' }
 
-    it "loads the data" do
-      expect(subject).to eq "hello"
+    it 'loads the data' do
+      expect(subject).to eq 'hello'
     end
   end
 
   context "with a URL that's not a data scheme" do
-    let(:url) { "http://some.host" }
+    let(:url) { 'http://some.host' }
 
-    it "returns nil" do
+    it 'returns nil' do
       expect(subject).to be nil
     end
   end
 
   context "with a data URL that's not an image" do
-    let(:url) { "data:application/pdf;base64,aGVsbG8=" }
+    let(:url) { 'data:application/pdf;base64,aGVsbG8=' }
 
-    it "raises" do
+    it 'raises' do
       expect { subject }.to raise_error Prawn::SVG::UrlLoader::Error, /image/
     end
   end
 
   context "with a data URL that's not base64 encoded" do
-    let(:url) { "data:image/png;base32,agvsbg" }
+    let(:url) { 'data:image/png;base32,agvsbg' }
 
-    it "raises" do
+    it 'raises' do
       expect { subject }.to raise_error Prawn::SVG::UrlLoader::Error, /base64/
     end
   end

data/spec/prawn/svg/loaders/file_spec.rb

@@ -1,71 +1,73 @@
 require 'spec_helper'
 
 RSpec.describe Prawn::SVG::Loaders::File do
-  let(:root_path) { "." }
-  let(:fake_root_path) { "/some" }
+  let(:root_path) { '.' }
+  let(:fake_root_path) { '/some' }
 
   let(:file_loader) { Prawn::SVG::Loaders::File.new(root_path) }
   subject { file_loader.from_url(url) }
 
-  context "when an invalid path is supplied" do
-    let(:root_path) { "/does/not/exist" }
+  context 'when an invalid path is supplied' do
+    let(:root_path) { '/does/not/exist' }
 
-    it "raises with an ArgumentError" do
+    it 'raises with an ArgumentError' do
       expect { subject }.to raise_error ArgumentError, /is not a directory/
     end
   end
 
-  context "when a relative path is supplied" do
-    let(:url) { "relative/./path" }
+  context 'when a relative path is supplied' do
+    let(:url) { 'relative/./path' }
 
-    it "loads the file" do
-      expect(File).to receive(:expand_path).with(".").and_return(fake_root_path)
-      expect(File).to receive(:expand_path).with("relative/./path", fake_root_path).and_return("#{fake_root_path}/relative/path")
+    it 'loads the file' do
+      expect(File).to receive(:expand_path).with('.').and_return(fake_root_path)
+      expect(File).to receive(:expand_path).with('relative/./path',
+        fake_root_path).and_return("#{fake_root_path}/relative/path")
 
       expect(Dir).to receive(:exist?).with(fake_root_path).and_return(true)
       expect(File).to receive(:exist?).with("#{fake_root_path}/relative/path").and_return(true)
-      expect(IO).to receive(:binread).with("#{fake_root_path}/relative/path").and_return("data")
+      expect(File).to receive(:binread).with("#{fake_root_path}/relative/path").and_return('data')
 
       expect(subject).to eq 'data'
     end
   end
 
-  context "when an absolute path without file scheme is supplied" do
-    let(:url) { "/some/absolute/./path" }
+  context 'when an absolute path without file scheme is supplied' do
+    let(:url) { '/some/absolute/./path' }
 
-    it "loads the file" do
-      expect(File).to receive(:expand_path).with(".").and_return(fake_root_path)
-      expect(File).to receive(:expand_path).with(url, fake_root_path).and_return("/some/absolute/path")
+    it 'loads the file' do
+      expect(File).to receive(:expand_path).with('.').and_return(fake_root_path)
+      expect(File).to receive(:expand_path).with(url, fake_root_path).and_return('/some/absolute/path')
 
       expect(Dir).to receive(:exist?).with(fake_root_path).and_return(true)
-      expect(File).to receive(:exist?).with("/some/absolute/path").and_return(true)
-      expect(IO).to receive(:binread).with("/some/absolute/path").and_return("data")
+      expect(File).to receive(:exist?).with('/some/absolute/path').and_return(true)
+      expect(File).to receive(:binread).with('/some/absolute/path').and_return('data')
 
       expect(subject).to eq 'data'
     end
   end
 
-  context "when an absolute path with file scheme is supplied" do
-    let(:url) { "file:///some/absolute/./path%20name" }
+  context 'when an absolute path with file scheme is supplied' do
+    let(:url) { 'file:///some/absolute/./path%20name' }
 
-    it "loads the file" do
-      expect(File).to receive(:expand_path).with(".").and_return(fake_root_path)
-      expect(File).to receive(:expand_path).with("/some/absolute/./path name", fake_root_path).and_return("/some/absolute/path name")
+    it 'loads the file' do
+      expect(File).to receive(:expand_path).with('.').and_return(fake_root_path)
+      expect(File).to receive(:expand_path).with('/some/absolute/./path name',
+        fake_root_path).and_return('/some/absolute/path name')
 
       expect(Dir).to receive(:exist?).with(fake_root_path).and_return(true)
-      expect(File).to receive(:exist?).with("/some/absolute/path name").and_return(true)
-      expect(IO).to receive(:binread).with("/some/absolute/path name").and_return("data")
+      expect(File).to receive(:exist?).with('/some/absolute/path name').and_return(true)
+      expect(File).to receive(:binread).with('/some/absolute/path name').and_return('data')
 
       expect(subject).to eq 'data'
     end
   end
 
-  context "when a path outside of our root is specified" do
-    let(:url) { "/other/absolute/./path" }
+  context 'when a path outside of our root is specified' do
+    let(:url) { '/other/absolute/./path' }
 
-    it "raises" do
-      expect(File).to receive(:expand_path).with(".").and_return(fake_root_path)
-      expect(File).to receive(:expand_path).with(url, fake_root_path).and_return("/other/absolute/path")
+    it 'raises' do
+      expect(File).to receive(:expand_path).with('.').and_return(fake_root_path)
+      expect(File).to receive(:expand_path).with(url, fake_root_path).and_return('/other/absolute/path')
 
       expect(Dir).to receive(:exist?).with(fake_root_path).and_return(true)
 
@@ -73,11 +75,11 @@ RSpec.describe Prawn::SVG::Loaders::File do
     end
   end
 
-  context "when a file: url with a host is specified" do
-    let(:url) { "file://somewhere/somefile" }
+  context 'when a file: url with a host is specified' do
+    let(:url) { 'file://somewhere/somefile' }
 
-    it "raises" do
-      expect(File).to receive(:expand_path).with(".").and_return(fake_root_path)
+    it 'raises' do
+      expect(File).to receive(:expand_path).with('.').and_return(fake_root_path)
       expect(Dir).to receive(:exist?).with(fake_root_path).and_return(true)
 
       expect { subject }.to raise_error Prawn::SVG::UrlLoader::Error, /with a host/
@@ -85,16 +87,17 @@ RSpec.describe Prawn::SVG::Loaders::File do
   end
 
   context "when we're running on Windows" do
-    let(:url) { "file:///c:/path/to/file.png" }
-    let(:fake_root_path) { "c:/full" }
+    let(:url) { 'file:///c:/path/to/file.png' }
+    let(:fake_root_path) { 'c:/full' }
 
     it "automatically fixes up URI's misparsing of Windows file paths and loads the file" do
-      expect(File).to receive(:expand_path).with(".").and_return(fake_root_path)
-      expect(File).to receive(:expand_path).with("c:/path/to/file.png", fake_root_path).and_return("c:/full/path/to/file.png")
+      expect(File).to receive(:expand_path).with('.').and_return(fake_root_path)
+      expect(File).to receive(:expand_path).with('c:/path/to/file.png',
+        fake_root_path).and_return('c:/full/path/to/file.png')
 
       expect(Dir).to receive(:exist?).with(fake_root_path).and_return(true)
-      expect(File).to receive(:exist?).with("c:/full/path/to/file.png").and_return(true)
-      expect(IO).to receive(:binread).with("c:/full/path/to/file.png").and_return("data")
+      expect(File).to receive(:exist?).with('c:/full/path/to/file.png').and_return(true)
+      expect(File).to receive(:binread).with('c:/full/path/to/file.png').and_return('data')
 
       allow(file_loader).to receive(:windows?).and_return true
       expect(subject).to eq 'data'

data/spec/prawn/svg/loaders/web_spec.rb

@@ -1,36 +1,36 @@
 require 'spec_helper'
 
 RSpec.describe Prawn::SVG::Loaders::Web do
-  let(:url) { "http://hello.there/path" }
+  let(:url) { 'http://hello.there/path' }
   let(:uri) { URI(url) }
 
   subject { Prawn::SVG::Loaders::Web.new.from_url(url) }
 
-  it "loads an HTTP URL" do
-    expect(Net::HTTP).to receive(:get).with(uri).and_return("hello!")
-    expect(subject).to eq "hello!"
+  it 'loads an HTTP URL' do
+    expect(Net::HTTP).to receive(:get).with(uri).and_return('hello!')
+    expect(subject).to eq 'hello!'
   end
 
-  context "with an https URL" do
-    let(:url) { "https://hello.there/path"}
+  context 'with an https URL' do
+    let(:url) { 'https://hello.there/path' }
 
-    it "loads the HTTPS URL" do
-      expect(Net::HTTP).to receive(:get).with(uri).and_return("hello!")
-      expect(subject).to eq "hello!"
+    it 'loads the HTTPS URL' do
+      expect(Net::HTTP).to receive(:get).with(uri).and_return('hello!')
+      expect(subject).to eq 'hello!'
     end
   end
 
-  context "when the HTTP call raises" do
-    it "re-raises the error as UrlLoader errors" do
-      expect(Net::HTTP).to receive(:get).with(uri).and_raise(SocketError, "argh")
+  context 'when the HTTP call raises' do
+    it 're-raises the error as UrlLoader errors' do
+      expect(Net::HTTP).to receive(:get).with(uri).and_raise(SocketError, 'argh')
       expect { subject }.to raise_error Prawn::SVG::UrlLoader::Error, 'argh'
     end
   end
 
-  context "with a non-http, non-https URL" do
-    let(:url) { "mailto:someone@something" }
+  context 'with a non-http, non-https URL' do
+    let(:url) { 'mailto:someone@something' }
 
-    it "returns nil" do
+    it 'returns nil' do
       expect(subject).to be nil
     end
   end

data/spec/prawn/svg/pathable_spec.rb

@@ -22,68 +22,68 @@ RSpec.describe Prawn::SVG::Pathable do
     end
   end
 
-  let(:document) { Prawn::SVG::Document.new("<svg></svg>", [800, 600], {width: 800, height: 600}) }
+  let(:document) { Prawn::SVG::Document.new('<svg></svg>', [800, 600], { width: 800, height: 600 }) }
   let(:state) { Prawn::SVG::State.new }
 
   subject do
     FakeElement.new(document, document.root, [], state)
   end
 
-  describe "#bounding_box" do
-    it "determines the bounding box using the translated commands" do
+  describe '#bounding_box' do
+    it 'determines the bounding box using the translated commands' do
       expect(subject.bounding_box).to eq [10, 590, 30, 570]
     end
   end
 
-  describe "#apply_commands" do
-    it "applies the commands to the call stack" do
+  describe '#apply_commands' do
+    it 'applies the commands to the call stack' do
       subject.apply_commands
 
       expect(subject.base_calls).to eq [
-        ["move_to", [[10.0, 590.0]], {}, []],
-        ["line_to", [[20.0, 580.0]], {}, []],
-        ["curve_to", [[30.0, 570.0]], {bounds: [[25.0, 580.0], [25.0, 575.0]]}, []],
-        ["close_path", [], {}, []]
+        ['move_to', [[10.0, 590.0]], {}, []],
+        ['line_to', [[20.0, 580.0]], {}, []],
+        ['curve_to', [[30.0, 570.0]], { bounds: [[25.0, 580.0], [25.0, 575.0]] }, []],
+        ['close_path', [], {}, []]
       ]
     end
   end
 
-  describe "#apply_markers" do
-    let(:marker) { instance_double(Prawn::SVG::Elements::Marker, name: "marker") }
+  describe '#apply_markers' do
+    let(:marker) { instance_double(Prawn::SVG::Elements::Marker, name: 'marker') }
 
     before do
-      document.elements_by_id["triangle"] = marker
+      document.elements_by_id['triangle'] = marker
     end
 
-    context "with marker-start attribute specified" do
+    context 'with marker-start attribute specified' do
       before do
-        subject.properties.marker_start = "url(#triangle)"
+        subject.properties.marker_start = 'url(#triangle)'
       end
 
-      it "calls apply_marker on the marker" do
+      it 'calls apply_marker on the marker' do
         expect(marker).to receive(:apply_marker).with(subject, point: [10, 10], angle: 45)
         subject.apply_markers
       end
     end
 
-    context "with marker-mid attribute specified" do
+    context 'with marker-mid attribute specified' do
       before do
-        subject.properties.marker_mid = "url(#triangle)"
+        subject.properties.marker_mid = 'url(#triangle)'
       end
 
-      it "calls apply_marker on the marker" do
+      it 'calls apply_marker on the marker' do
         expect(marker).to receive(:apply_marker).with(subject, point: [20, 20], angle: 45)
         expect(marker).to receive(:apply_marker).with(subject, point: [30, 30], angle: -45)
         subject.apply_markers
       end
     end
 
-    context "with marker-end attribute specified" do
+    context 'with marker-end attribute specified' do
       before do
-        subject.properties.marker_end = "url(#triangle)"
+        subject.properties.marker_end = 'url(#triangle)'
       end
 
-      it "calls apply_marker on the marker" do
+      it 'calls apply_marker on the marker' do
         expect(marker).to receive(:apply_marker).with(subject, point: [10, 10], angle: -45)
         subject.apply_markers
       end