prawn-svg 0.34.2 → 0.35.1

data/spec/prawn/svg/properties_spec.rb

@@ -3,27 +3,27 @@ require 'spec_helper'
 RSpec.describe Prawn::SVG::Properties do
   subject { Prawn::SVG::Properties.new }
 
-  describe "#load_default_stylesheet" do
-    it "loads in the defaults and returns self" do
+  describe '#load_default_stylesheet' do
+    it 'loads in the defaults and returns self' do
       expect(subject.load_default_stylesheet).to eq subject
       expect(subject.font_family).to eq 'sans-serif'
     end
   end
 
-  describe "#set" do
-    it "sets a property" do
+  describe '#set' do
+    it 'sets a property' do
       result = subject.set('color', 'red')
       expect(result).to be
       expect(subject.color).to eq 'red'
     end
 
-    it "handles property names that are not lower case" do
+    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'
     end
 
-    it "right-cases and strips keywords" do
+    it 'right-cases and strips keywords' do
       subject.set('stroke-linecap', ' Round ')
       expect(subject.stroke_linecap).to eq 'round'
     end
@@ -39,19 +39,19 @@ RSpec.describe Prawn::SVG::Properties do
     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")
+  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_linecap).to eq 'round'
     end
   end
 
-  describe "#compute_properties" do
+  describe '#compute_properties' do
     let(:other) { Prawn::SVG::Properties.new }
 
-    it "auto-inherits inheritable properties when the property is not supplied" 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'
@@ -63,122 +63,122 @@ RSpec.describe Prawn::SVG::Properties do
       expect(subject.display).to eq 'inline'
     end
 
-    it "inherits non-inheritable properties when specifically asked to" do
+    it 'inherits non-inheritable properties when specifically asked to' do
       subject.set('display', 'none')
       other.set('display', 'inherit')
       subject.compute_properties(other)
       expect(subject.display).to eq 'none'
     end
 
-    it "uses the new property value" do
+    it 'uses the new property value' do
       subject.set('color', 'green')
       other.set('color', 'red')
       subject.compute_properties(other)
       expect(subject.color).to eq 'red'
     end
 
-    describe "font size" do
+    describe 'font size' do
       before do
-        subject.font_size = "15"
+        subject.font_size = '15'
         other.font_size = font_size
       end
 
-      context "when given a % as a font-size" do
-        let(:font_size) { "120%" }
+      context 'when given a % as a font-size' do
+        let(:font_size) { '120%' }
 
-        it "calculates the new font size" do
+        it 'calculates the new font size' do
           subject.compute_properties(other)
-          expect(subject.font_size).to eq "18.0"
+          expect(subject.font_size).to eq '18.0'
         end
       end
 
       context "when given 'larger' as a font-size" do
-        let(:font_size) { "larger" }
+        let(:font_size) { 'larger' }
 
-        it "calculates the new font size" do
+        it 'calculates the new font size' do
           subject.compute_properties(other)
-          expect(subject.font_size).to eq "19.0"
+          expect(subject.font_size).to eq '19.0'
         end
       end
 
       context "when given 'smaller' as a font-size" do
-        let(:font_size) { "smaller" }
+        let(:font_size) { 'smaller' }
 
-        it "calculates the new font size" do
+        it 'calculates the new font size' do
           subject.compute_properties(other)
-          expect(subject.font_size).to eq "11.0"
+          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" }
+        let(:font_size) { '2.5em' }
 
-        it "calculates the new font size" do
+        it 'calculates the new font size' do
           subject.compute_properties(other)
-          expect(subject.font_size).to eq "37.5"
+          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" }
+        let(:font_size) { '2.5rem' }
 
-        it "calculates the new font size" do
+        it 'calculates the new font size' do
           subject.compute_properties(other)
-          expect(subject.font_size).to eq "40.0"
+          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" }
+        let(:font_size) { '19.5px' }
 
-        it "uses the font size specified" do
+        it 'uses the font size specified' do
           subject.compute_properties(other)
-          expect(subject.font_size).to eq "19.5"
+          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" }
+        let(:font_size) { '19.5pt' }
 
-        it "uses the font size specified" do
+        it 'uses the font size specified' do
           subject.compute_properties(other)
-          expect(subject.font_size).to eq "19.5"
+          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" }
+      context 'when given a value without units as a font-size' do
+        let(:font_size) { '19.5' }
 
-        it "uses the font size specified" do
+        it 'uses the font size specified' do
           subject.compute_properties(other)
-          expect(subject.font_size).to eq "19.5"
+          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" }
+        let(:font_size) { 'inherit' }
 
-        it "uses the font size specified by the parent" do
+        it 'uses the font size specified by the parent' do
           subject.compute_properties(other)
-          expect(subject.font_size).to eq "15"
+          expect(subject.font_size).to eq '15'
         end
       end
     end
   end
 
-  describe "#numerical_font_size" do
-    context "when the font size is a number" do
-      before { subject.font_size = "16.5" }
+  describe '#numerical_font_size' do
+    context 'when the font size is a number' do
+      before { subject.font_size = '16.5' }
 
-      it "returns the number as a float" do
+      it 'returns the number as a float' do
         expect(subject.numerical_font_size).to eq 16.5
       end
     end
 
-    context "when the font size is one of the keyword size specifiers" do
-      before { subject.font_size = "x-large" }
+    context 'when the font size is one of the keyword size specifiers' do
+      before { subject.font_size = 'x-large' }
 
-      it "returns the font size number corresponding with the keyword" do
+      it 'returns the font size number corresponding with the keyword' do
         expect(subject.numerical_font_size).to eq 24
       end
     end

data/spec/prawn/svg/transform_parser_spec.rb

@@ -28,27 +28,27 @@ RSpec.describe Prawn::SVG::TransformParser do
 
   subject { Test.new.parse_transform_attribute(transform) }
 
-  context "with no transform" do
+  context 'with no transform' do
     let(:transform) { '' }
     it { is_expected.to eq [1, 0, 0, 1, 0, 0] }
   end
 
-  context "with translate" do
+  context 'with translate' do
     let(:transform) { 'translate(10 20)' }
     it { is_expected.to eq [1, 0, 0, 1, 10, -20] }
   end
 
-  context "with single argument translate" do
+  context 'with single argument translate' do
     let(:transform) { 'translate(10)' }
     it { is_expected.to eq [1, 0, 0, 1, 10, 0] }
   end
 
-  context "with translateX" do
+  context 'with translateX' do
     let(:transform) { 'translateX(10)' }
     it { is_expected.to eq [1, 0, 0, 1, 10, 0] }
   end
 
-  context "with translateY" do
+  context 'with translateY' do
     let(:transform) { 'translateY(10)' }
     it { is_expected.to eq [1, 0, 0, 1, 0, -10] }
   end
@@ -57,37 +57,37 @@ RSpec.describe Prawn::SVG::TransformParser do
   let(:cos30) { Math.cos(30 * Math::PI / 180.0) }
   let(:tan30) { Math.tan(30 * Math::PI / 180.0) }
 
-  context "with single argument rotate" do
+  context 'with single argument rotate' do
     let(:transform) { 'rotate(30)' }
     it { is_expected.to eq [cos30, -sin30, sin30, cos30, 0, 0] }
   end
 
-  context "with triple argument rotate" do
+  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] }
   end
 
-  context "with scale" do
+  context 'with scale' do
     let(:transform) { 'scale(1.5)' }
     it { is_expected.to eq [1.5, 0, 0, 1.5, 0, 0] }
   end
 
-  context "with skewX" do
+  context 'with skewX' do
     let(:transform) { 'skewX(30)' }
     it { is_expected.to eq [1, 0, -tan30, 1, 0, 0] }
   end
 
-  context "with skewY" do
+  context 'with skewY' do
     let(:transform) { 'skewY(30)' }
     it { is_expected.to eq [1, -tan30, 0, 1, 0, 0] }
   end
 
-  context "with matrix" do
+  context 'with matrix' do
     let(:transform) { 'matrix(1 2 3 4 5 6)' }
     it { is_expected.to eq [1, -2, -3, 4, 5, -6] }
   end
 
-  context "with multiple" do
+  context 'with multiple' do
     let(:transform) { 'scale(2) translate(7) scale(3)' }
     it { is_expected.to eq [6, 0, 0, 6, 14, 0] }
   end

data/spec/prawn/svg/ttf_spec.rb

@@ -3,10 +3,10 @@ require 'spec_helper'
 RSpec.describe Prawn::SVG::TTF do
   subject { Prawn::SVG::TTF.new(filename) }
 
-  context "with a truetype font" do
+  context 'with a truetype font' do
     let(:filename) { "#{File.dirname(__FILE__)}/../../sample_ttf/OpenSans-SemiboldItalic.ttf" }
 
-    it "gets the English family and subfamily from the font file" do
+    it 'gets the English family and subfamily from the font file' do
       expect(subject.family).to eq 'Open Sans'
       expect(subject.subfamily).to eq 'Semibold Italic'
     end
@@ -15,16 +15,16 @@ RSpec.describe Prawn::SVG::TTF do
   context "with a file that isn't a TTF" do
     let(:filename) { __FILE__ }
 
-    it "has a nil family and subfamily" do
+    it 'has a nil family and subfamily' do
       expect(subject.family).to be nil
       expect(subject.subfamily).to be nil
     end
   end
 
   context "with a file that doesn't exist" do
-    let(:filename) { "does_not_exist" }
+    let(:filename) { 'does_not_exist' }
 
-    it "has a nil family and subfamily" do
+    it 'has a nil family and subfamily' do
       expect(subject.family).to be nil
       expect(subject.subfamily).to be nil
     end

data/spec/prawn/svg/url_loader_spec.rb

@@ -3,17 +3,19 @@ require 'spec_helper'
 describe Prawn::SVG::UrlLoader do
   let(:enable_cache) { true }
   let(:enable_web)   { true }
-  let(:enable_file)  { "." }
-  let(:loader) { Prawn::SVG::UrlLoader.new(enable_cache: enable_cache, enable_web: enable_web, enable_file_with_root: enable_file) }
+  let(:enable_file)  { '.' }
+  let(:loader) do
+    Prawn::SVG::UrlLoader.new(enable_cache: enable_cache, enable_web: enable_web, enable_file_with_root: enable_file)
+  end
 
-  describe "#initialize" do
-    it "sets options" do
+  describe '#initialize' do
+    it 'sets options' do
       expect(loader.enable_cache).to be true
     end
   end
 
-  describe "#load" do
-    let(:url) { "http://hello/there" }
+  describe '#load' do
+    let(:url) { 'http://hello/there' }
     let(:data_loader) { instance_double(Prawn::SVG::Loaders::Data) }
     let(:web_loader) { instance_double(Prawn::SVG::Loaders::Web) }
     let(:file_loader) { instance_double(Prawn::SVG::Loaders::File) }
@@ -26,29 +28,29 @@ describe Prawn::SVG::UrlLoader do
 
     subject { loader.load(url) }
 
-    it "calls the Data loader and returns its output if successful" do
-      expect(data_loader).to receive(:from_url).with(url).and_return("data")
+    it 'calls the Data loader and returns its output if successful' do
+      expect(data_loader).to receive(:from_url).with(url).and_return('data')
       expect(web_loader).not_to receive(:from_url)
 
       expect(subject).to eq 'data'
     end
 
-    it "calls the Web loader if the Data loader returns nothing, and returns its output if successful" do
+    it 'calls the Web loader if the Data loader returns nothing, and returns its output if successful' do
       expect(data_loader).to receive(:from_url).with(url)
-      expect(web_loader).to receive(:from_url).with(url).and_return("data")
+      expect(web_loader).to receive(:from_url).with(url).and_return('data')
 
       expect(subject).to eq 'data'
     end
 
-    it "calls the File loader if the Data and Web loaders return nothing, and returns its output if successful" do
+    it 'calls the File loader if the Data and Web loaders return nothing, and returns its output if successful' do
       expect(data_loader).to receive(:from_url).with(url)
       expect(web_loader).to receive(:from_url).with(url)
-      expect(file_loader).to receive(:from_url).with(url).and_return("data")
+      expect(file_loader).to receive(:from_url).with(url).and_return('data')
 
       expect(subject).to eq 'data'
     end
 
-    it "raises if none of the loaders return any data" do
+    it 'raises if none of the loaders return any data' do
       expect(data_loader).to receive(:from_url).with(url)
       expect(web_loader).to receive(:from_url).with(url)
       expect(file_loader).to receive(:from_url).with(url)
@@ -56,28 +58,28 @@ describe Prawn::SVG::UrlLoader do
       expect { subject }.to raise_error(Prawn::SVG::UrlLoader::Error, /No handler available/)
     end
 
-    context "when caching is enabled" do
-      it "caches the result" do
-        expect(data_loader).to receive(:from_url).with(url).and_return("data")
+    context 'when caching is enabled' do
+      it 'caches the result' do
+        expect(data_loader).to receive(:from_url).with(url).and_return('data')
         expect(subject).to eq 'data'
         expect(loader.retrieve_from_cache(url)).to eq 'data'
       end
     end
 
-    context "when caching is disabled" do
+    context 'when caching is disabled' do
       let(:enable_cache) { false }
 
-      it "does not cache the result" do
-        expect(data_loader).to receive(:from_url).with(url).and_return("data")
+      it 'does not cache the result' do
+        expect(data_loader).to receive(:from_url).with(url).and_return('data')
         expect(subject).to eq 'data'
         expect(loader.retrieve_from_cache(url)).to be nil
       end
     end
 
-    context "when the cache is populated" do
+    context 'when the cache is populated' do
       before { loader.add_to_cache(url, 'data') }
 
-      it "returns the cached value without calling a loader" do
+      it 'returns the cached value without calling a loader' do
         expect(data_loader).not_to receive(:from_url)
         expect(web_loader).not_to receive(:from_url)
 
@@ -85,7 +87,7 @@ describe Prawn::SVG::UrlLoader do
       end
     end
 
-    context "when web requests are disabled" do
+    context 'when web requests are disabled' do
       let(:enable_web) { false }
 
       it "doesn't use the web loader" do
@@ -97,7 +99,7 @@ describe Prawn::SVG::UrlLoader do
       end
     end
 
-    context "when file requests are disabled" do
+    context 'when file requests are disabled' do
       let(:enable_file) { nil }
 
       it "doesn't use the file loader" do

data/spec/spec_helper.rb

@@ -3,7 +3,7 @@ Bundler.require(:default, :development)
 
 # Requires supporting files with custom matchers and macros, etc,
 # in ./support/ and its subdirectories.
-Dir["#{File.dirname(__FILE__)}/support/**/*.rb"].each { |f| require f }
+Dir["#{File.dirname(__FILE__)}/support/**/*.rb"].sort.each { |f| require f }
 
 module Support
   def flatten_calls(_calls)
@@ -49,15 +49,15 @@ RSpec.configure do |config|
 
   config.after(:suite) do
     # print out the PDFs that have changed
-    changed = $hashes.select do |file, hash|
+    changed = $hashes.reject do |file, hash|
       new_hash = Digest::MD5.file(file).hexdigest
-      new_hash != hash
+      new_hash == hash
     end
 
     if changed.any?
       puts "\nThese PDFs have changed since the last test run:"
       cwd = "#{Dir.pwd}/"
-      changed.each { |file, _| puts "  #{file.sub(cwd, '')}" }
+      changed.each_key { |file| puts "  #{file.sub(cwd, '')}" }
     end
   end
 end