prawn-svg 0.34.2 → 0.35.0

data/lib/prawn/svg/state.rb

@@ -12,7 +12,7 @@ class Prawn::SVG::State
     @computed_properties = Prawn::SVG::Properties.new.load_default_stylesheet
   end
 
-  def initialize_dup(other)
+  def initialize_dup(_other)
     @computed_properties = @computed_properties.dup
   end
 

data/lib/prawn/svg/transform_parser.rb

@@ -17,7 +17,7 @@ module Prawn::SVG::TransformParser
         matrix *= Matrix[[1, 0, 0], [0, 1, -y_pixels(y.to_f)], [0, 0, 1]]
 
       when 'rotate'
-        angle, x, y = arguments.collect { |a| a.to_f }
+        angle, x, y = arguments.collect(&:to_f)
         angle = angle * Math::PI / 180.0
 
         case arguments.length
@@ -45,11 +45,11 @@ module Prawn::SVG::TransformParser
         matrix *= Matrix[[1, 0, 0], [-Math.tan(angle), 1, 0], [0, 0, 1]]
 
       when 'matrix'
-        if arguments.length != 6
-          warnings << "transform 'matrix' must have six arguments"
-        else
-          a, b, c, d, e, f = arguments.collect { |argument| argument.to_f }
+        if arguments.length == 6
+          a, b, c, d, e, f = arguments.collect(&:to_f)
           matrix *= Matrix[[a, -c, e], [-b, d, -f], [0, 0, 1]]
+        else
+          warnings << "transform 'matrix' must have six arguments"
         end
 
       else

data/lib/prawn/svg/ttf.rb

@@ -1,7 +1,7 @@
 class Prawn::SVG::TTF
-  SFNT_VERSION_STRINGS = ["\x00\x01\x00\x00", "true", "typ1"]
-  LANGUAGE_IDS = [0, 0x409] # English, US English
-  UTF_16BE_PLATFORM_IDS = [0, 3] # Unicode, Microsoft
+  SFNT_VERSION_STRINGS = ["\x00\x01\x00\x00", 'true', 'typ1'].freeze
+  LANGUAGE_IDS = [0, 0x409].freeze # English, US English
+  UTF_16BE_PLATFORM_IDS = [0, 3].freeze # Unicode, Microsoft
 
   attr_reader :family, :subfamily
 
@@ -12,45 +12,49 @@ class Prawn::SVG::TTF
   private
 
   def load_data_from_file(filename)
-    File.open(filename, "rb") do |f|
+    File.open(filename, 'rb') do |f|
       offset_table = f.read(12)
       return unless offset_table && offset_table.length == 12 && SFNT_VERSION_STRINGS.include?(offset_table[0..3])
 
-      table_count = offset_table[4].ord * 256 + offset_table[5].ord
+      table_count = (offset_table[4].ord * 256) + offset_table[5].ord
       tables = f.read(table_count * 16)
       return unless tables && tables.length == table_count * 16
 
       offset, length = table_count.times do |index|
         start = index * 16
-        if tables[start..start+3] == 'name'
-          break tables[start+8..start+15].unpack("NNN")
-        end
+        break tables[start + 8..start + 15].unpack('NNN') if tables[start..start + 3] == 'name'
       end
 
       return unless length
+
       f.seek(offset)
       data = f.read(length)
       return unless data && data.length == length
 
-      format, name_count, string_offset = data[0..5].unpack("nnn")
+      _, name_count, string_offset = data[0..5].unpack('nnn')
 
       names = {}
       name_count.times do |index|
-        start = 6 + index * 12
-        platform_id, platform_specific_id, language_id, name_id, length, offset = data[start..start+11].unpack("nnnnnn")
+        start = 6 + (index * 12)
+        platform_id, _, language_id, name_id, length, offset = data[start..start + 11].unpack('nnnnnn')
         next unless offset
         next unless LANGUAGE_IDS.include?(language_id)
         next unless [1, 2, 16, 17].include?(name_id)
 
         offset += string_offset
-        field = data[offset..offset+length-1]
+        field = data[offset..offset + length - 1]
         next unless field && field.length == length
 
-        names[name_id] = if UTF_16BE_PLATFORM_IDS.include?(platform_id)
-          field.force_encoding(Encoding::UTF_16BE).encode(Encoding::UTF_8) rescue field
-        else
-          field
-        end
+        names[name_id] =
+          if UTF_16BE_PLATFORM_IDS.include?(platform_id)
+            begin
+              field.force_encoding(Encoding::UTF_16BE).encode(Encoding::UTF_8)
+            rescue StandardError
+              field
+            end
+          else
+            field
+          end
       end
 
       @family = names[16] || names[1]

data/lib/prawn/svg/url_loader.rb

@@ -34,7 +34,7 @@ class Prawn::SVG::UrlLoader
   end
 
   def perform(url)
-    try_each_loader(url) or raise Error, "No handler available for this URL scheme"
+    try_each_loader(url) or raise Error, 'No handler available for this URL scheme'
   end
 
   def try_each_loader(url)

data/lib/prawn/svg/version.rb

@@ -1,5 +1,5 @@
 module Prawn
   module SVG
-    VERSION = '0.34.2'
+    VERSION = '0.35.0'.freeze
   end
 end

data/lib/prawn-svg.rb

@@ -26,6 +26,7 @@ require 'prawn/svg/interface'
 require 'prawn/svg/css/font_family_parser'
 require 'prawn/svg/css/selector_parser'
 require 'prawn/svg/css/stylesheets'
+require 'prawn/svg/css/values_parser'
 require 'prawn/svg/ttf'
 require 'prawn/svg/font'
 require 'prawn/svg/gradients'

data/prawn-svg.gemspec

@@ -4,9 +4,9 @@ Gem::Specification.new do |gem|
   gem.name = 'prawn-svg'
   gem.version = Prawn::SVG::VERSION
   gem.summary = 'SVG renderer for Prawn PDF library'
-  gem.description = <<-EOT.strip
+  gem.description = <<-DESC.strip
     This gem allows you to render SVG directly into a PDF using the 'prawn' gem.  Since PDF is vector-based, you'll get nice scaled graphics if you use SVG instead of an image.
-  EOT
+  DESC
   gem.author = 'Mog Nesbitt'
   gem.email = 'mog@seriousorange.com'
   gem.homepage = 'http://github.com/mogest/prawn-svg'
@@ -14,15 +14,13 @@ Gem::Specification.new do |gem|
 
   gem.executables   = `git ls-files -- bin/*`.split("\n").map { |f| File.basename(f) }
   gem.files         = `git ls-files`.split("\n")
-  gem.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
   gem.require_paths = ['lib']
+  gem.metadata      = { 'rubygems_mfa_required' => 'true' }
 
-  gem.required_ruby_version = '>= 2.5.0'
+  gem.required_ruby_version = '>= 2.7.0'
 
   gem.add_runtime_dependency 'css_parser', '~> 1.6'
   gem.add_runtime_dependency 'matrix', '~> 0.4.2'
   gem.add_runtime_dependency 'prawn', '>= 0.11.1', '< 3'
   gem.add_runtime_dependency 'rexml', '~> 3.2'
-  gem.add_development_dependency 'rake', '~> 13.0'
-  gem.add_development_dependency 'rspec', '~> 3.0'
 end

data/spec/integration_spec.rb

@@ -1,100 +1,100 @@
 require 'spec_helper'
 
-describe "Integration test" do
+describe 'Integration test' do
   root = "#{File.dirname(__FILE__)}/.."
 
-  describe "a basic SVG file" do
+  describe 'a basic SVG file' do
     let(:document) { Prawn::SVG::Document.new(svg, [800, 600], {}) }
     let(:element) { Prawn::SVG::Elements::Root.new(document) }
 
     let(:svg) do
-      <<-SVG
-<svg width="100" height="200">
-  <style><![CDATA[
-    #puppy  { fill: red; }
-    .animal { fill: green; }
-    rect    { fill: blue; }
-  ]]></style>
-
-  <rect x="0" y="0" width="10" height="10"/>
-  <rect x="10" y="0" width="10" height="10" class="animal"/>
-  <rect x="20" y="0" width="10" height="10" class="animal" id="puppy"/>
-  <rect x="30" y="0" width="10" height="10" class="animal" id="puppy" style="fill: yellow;"/>
-</svg>
+      <<~SVG
+        <svg width="100" height="200">
+          <style><![CDATA[
+            #puppy  { fill: red; }
+            .animal { fill: green; }
+            rect    { fill: blue; }
+          ]]></style>
+
+          <rect x="0" y="0" width="10" height="10"/>
+          <rect x="10" y="0" width="10" height="10" class="animal"/>
+          <rect x="20" y="0" width="10" height="10" class="animal" id="puppy"/>
+          <rect x="30" y="0" width="10" height="10" class="animal" id="puppy" style="fill: yellow;"/>
+        </svg>
       SVG
     end
 
-    it "is correctly converted to a call stack" do
+    it 'is correctly converted to a call stack' do
       element.process
 
       expect(element.calls).to eq [
-        ["fill_color", ["000000"], {}, []],
-        ["transformation_matrix", [1, 0, 0, 1, 0, 0], {}, []],
-        ["transformation_matrix", [1, 0, 0, 1, 0, 0], {}, []],
-        ["save", [], {}, []], ["restore", [], {}, []],
-        ["save", [], {}, []],
-        ["fill_color", ["0000ff"], {}, []],
-        ["fill", [], {}, [
-          ["rectangle", [[0.0, 200.0], 10.0, 10.0], {}, []]
+        ['fill_color', ['000000'], {}, []],
+        ['transformation_matrix', [1, 0, 0, 1, 0, 0], {}, []],
+        ['transformation_matrix', [1, 0, 0, 1, 0, 0], {}, []],
+        ['save', [], {}, []], ['restore', [], {}, []],
+        ['save', [], {}, []],
+        ['fill_color', ['0000ff'], {}, []],
+        ['fill', [], {}, [
+          ['rectangle', [[0.0, 200.0], 10.0, 10.0], {}, []]
         ]],
-        ["restore", [], {}, []],
-        ["save", [], {}, []],
-        ["fill_color", ["008000"], {}, []],
-        ["fill", [], {}, [
-          ["rectangle", [[10.0, 200.0], 10.0, 10.0], {}, []]
+        ['restore', [], {}, []],
+        ['save', [], {}, []],
+        ['fill_color', ['008000'], {}, []],
+        ['fill', [], {}, [
+          ['rectangle', [[10.0, 200.0], 10.0, 10.0], {}, []]
         ]],
-        ["restore", [], {}, []],
-        ["save", [], {}, []],
-        ["fill_color", ["ff0000"], {}, []],
-        ["fill", [], {}, [
-          ["rectangle", [[20.0, 200.0], 10.0, 10.0], {}, []]
+        ['restore', [], {}, []],
+        ['save', [], {}, []],
+        ['fill_color', ['ff0000'], {}, []],
+        ['fill', [], {}, [
+          ['rectangle', [[20.0, 200.0], 10.0, 10.0], {}, []]
         ]],
-        ["restore", [], {}, []],
-        ["save", [], {}, []],
-        ["fill_color", ["ffff00"], {}, []],
-        ["fill", [], {}, [
-          ["rectangle", [[30.0, 200.0], 10.0, 10.0], {}, []]
+        ['restore', [], {}, []],
+        ['save', [], {}, []],
+        ['fill_color', ['ffff00'], {}, []],
+        ['fill', [], {}, [
+          ['rectangle', [[30.0, 200.0], 10.0, 10.0], {}, []]
         ]],
-        ["restore", [], {}, []]
+        ['restore', [], {}, []]
       ]
     end
   end
 
-  context "with option :position" do
-    let(:svg) { IO.read("#{root}/spec/sample_svg/cubic01a.svg") }
+  context 'with option :position' do
+    let(:svg) { File.read("#{root}/spec/sample_svg/cubic01a.svg") }
 
-    it "aligns the image as requested" do
+    it 'aligns the image as requested' do
       Prawn::Document.generate("#{root}/spec/sample_output/_with_position.pdf") do |prawn|
         width = prawn.bounds.width / 3
 
-        prawn.svg svg, :width => width, :position => :left
-        prawn.svg svg, :width => width, :position => :center
-        prawn.svg svg, :width => width, :position => :right
-        prawn.svg svg, :width => width, :position => 50
-        prawn.svg svg, :width => width
+        prawn.svg svg, width: width, position: :left
+        prawn.svg svg, width: width, position: :center
+        prawn.svg svg, width: width, position: :right
+        prawn.svg svg, width: width, position: 50
+        prawn.svg svg, width: width
       end
     end
   end
 
-  context "with option :vposition" do
-    let(:svg) { IO.read("#{root}/spec/sample_svg/cubic01a.svg") }
+  context 'with option :vposition' do
+    let(:svg) { File.read("#{root}/spec/sample_svg/cubic01a.svg") }
 
-    it "aligns the image as requested" do
+    it 'aligns the image as requested' do
       Prawn::Document.generate("#{root}/spec/sample_output/_with_vposition.pdf") do |prawn|
         width = prawn.bounds.width / 3
 
-        prawn.svg svg, :width => width, :position => :left, :vposition => :bottom
-        prawn.svg svg, :width => width, :position => :center, :vposition => :center
-        prawn.svg svg, :width => width, :position => :right, :vposition => :top
-        prawn.svg svg, :width => width, :position => 50, :vposition => 50
+        prawn.svg svg, width: width, position: :left, vposition: :bottom
+        prawn.svg svg, width: width, position: :center, vposition: :center
+        prawn.svg svg, width: width, position: :right, vposition: :top
+        prawn.svg svg, width: width, position: 50, vposition: 50
       end
     end
   end
 
-  describe "sample file rendering" do
+  describe 'sample file rendering' do
     files = Dir["#{root}/spec/sample_svg/*.svg"]
 
-    it "has at least 10 SVG sample files to test" do
+    it 'has at least 10 SVG sample files to test' do
       files.length.should >= 10
     end
 
@@ -104,37 +104,44 @@ describe "Integration test" do
 
         warnings = nil
         Prawn::Document.generate("#{root}/spec/sample_output/#{File.basename file}.pdf") do |prawn|
-          r = prawn.svg IO.read(file), :at => [0, prawn.bounds.top], :width => prawn.bounds.width, :enable_file_requests_with_root => File.dirname(__FILE__) do |doc|
-            doc.url_loader.add_to_cache("https://raw.githubusercontent.com/mogest/prawn-svg/master/spec/sample_images/mushroom-wide.jpg", IO.read("#{root}/spec/sample_images/mushroom-wide.jpg"))
-            doc.url_loader.add_to_cache("https://raw.githubusercontent.com/mogest/prawn-svg/master/spec/sample_images/mushroom-long.jpg", IO.read("#{root}/spec/sample_images/mushroom-long.jpg"))
+          r = prawn.svg File.read(file), at: [0, prawn.bounds.top], width: prawn.bounds.width,
+            enable_file_requests_with_root: File.dirname(__FILE__) do |doc|
+            doc.url_loader.add_to_cache(
+              'https://raw.githubusercontent.com/mogest/prawn-svg/master/spec/sample_images/mushroom-wide.jpg', File.read("#{root}/spec/sample_images/mushroom-wide.jpg")
+            )
+            doc.url_loader.add_to_cache(
+              'https://raw.githubusercontent.com/mogest/prawn-svg/master/spec/sample_images/mushroom-long.jpg', File.read("#{root}/spec/sample_images/mushroom-long.jpg")
+            )
           end
 
-          warnings = r[:warnings].reject {|w| w =~ /Verdana/ && w =~ /is not a known font/ || w =~ /(render gradients$|waiting on the Prawn project)/}
+          warnings = r[:warnings].reject do |w|
+            (w =~ /Verdana/ && w =~ /is not a known font/) || w =~ /(render gradients$|waiting on the Prawn project)/
+          end
         end
         warnings.should == []
       end
     end
   end
 
-  describe "multiple file rendering" do
-    it "renders multiple files on to the same PDF" do
+  describe 'multiple file rendering' do
+    it 'renders multiple files on to the same PDF' do
       Prawn::Document.generate("#{root}/spec/sample_output/_multiple.pdf") do |prawn|
         width = prawn.bounds.width
 
         y = prawn.bounds.top - 12
-        prawn.draw_text "This is multiple SVGs being output to the same PDF", :at => [0, y]
+        prawn.draw_text 'This is multiple SVGs being output to the same PDF', at: [0, y]
 
         y -= 12
-        prawn.svg IO.read("#{root}/spec/sample_svg/arcs01.svg"),   :at => [0, y],         :width => width / 2
-        prawn.svg IO.read("#{root}/spec/sample_svg/circle01.svg"), :at => [width / 2, y], :width => width / 2
+        prawn.svg File.read("#{root}/spec/sample_svg/arcs01.svg"),   at: [0, y],         width: width / 2
+        prawn.svg File.read("#{root}/spec/sample_svg/circle01.svg"), at: [width / 2, y], width: width / 2
 
         y -= 120
-        prawn.draw_text "Here are some more PDFs below", :at => [0, y]
+        prawn.draw_text 'Here are some more PDFs below', at: [0, y]
 
         y -= 12
-        prawn.svg IO.read("#{root}/spec/sample_svg/quad01.svg"), :at => [0, y],             :width => width / 3
-        prawn.svg IO.read("#{root}/spec/sample_svg/rect01.svg"), :at => [width / 3, y],     :width => width / 3
-        prawn.svg IO.read("#{root}/spec/sample_svg/rect02.svg"), :at => [width / 3 * 2, y], :width => width / 3
+        prawn.svg File.read("#{root}/spec/sample_svg/quad01.svg"), at: [0, y],             width: width / 3
+        prawn.svg File.read("#{root}/spec/sample_svg/rect01.svg"), at: [width / 3, y],     width: width / 3
+        prawn.svg File.read("#{root}/spec/sample_svg/rect02.svg"), at: [width / 3 * 2, y], width: width / 3
       end
     end
   end

data/spec/prawn/svg/attributes/opacity_spec.rb

@@ -10,26 +10,22 @@ describe Prawn::SVG::Attributes::Opacity do
       @properties = ::Prawn::SVG::Properties.new
       @state = ::Prawn::SVG::State.new
     end
-
-    def clamp(value, min_value, max_value)
-      [[value, min_value].max, max_value].min
-    end
   end
 
   let(:element) { OpacityTestElement.new }
 
-  describe "#parse_opacity_attributes_and_call" do
+  describe '#parse_opacity_attributes_and_call' do
     subject { element.parse_opacity_attributes_and_call }
 
-    context "with no opacity specified" do
-      it "does nothing" do
+    context 'with no opacity specified' do
+      it 'does nothing' do
         expect(element).not_to receive(:add_call_and_enter)
         subject
       end
     end
 
-    context "with opacity" do
-      it "sets fill and stroke opacity" do
+    context 'with opacity' do
+      it 'sets fill and stroke opacity' do
         element.properties.opacity = '0.4'
 
         expect(element).to receive(:add_call_and_enter).with('transparent', 0.4, 0.4)
@@ -40,8 +36,8 @@ describe Prawn::SVG::Attributes::Opacity do
       end
     end
 
-    context "with just fill opacity" do
-      it "sets fill opacity and sets stroke opacity to 1" do
+    context 'with just fill opacity' do
+      it 'sets fill opacity and sets stroke opacity to 1' do
         element.properties.fill_opacity = '0.4'
 
         expect(element).to receive(:add_call_and_enter).with('transparent', 0.4, 1)
@@ -52,8 +48,8 @@ describe Prawn::SVG::Attributes::Opacity do
       end
     end
 
-    context "with an existing fill/stroke opacity" do
-      it "multiplies the new opacity by the old" do
+    context 'with an existing fill/stroke opacity' do
+      it 'multiplies the new opacity by the old' do
         element.state.fill_opacity = 0.5
         element.state.stroke_opacity = 0.8
 
@@ -68,8 +64,8 @@ describe Prawn::SVG::Attributes::Opacity do
       end
     end
 
-    context "with stroke, fill, and opacity all specified" do
-      it "choses the lower of them" do
+    context 'with stroke, fill, and opacity all specified' do
+      it 'choses the lower of them' do
         element.properties.fill_opacity = '0.4'
         element.properties.stroke_opacity = '0.6'
         element.properties.opacity = '0.5'

data/spec/prawn/svg/attributes/transform_spec.rb

@@ -16,10 +16,10 @@ describe Prawn::SVG::Attributes::Transform do
 
   subject { element.send :parse_transform_attribute_and_call }
 
-  context "when a non-identity matrix is requested" do
+  context 'when a non-identity matrix is requested' do
     let(:transform) { 'translate(-5.5)' }
 
-    it "passes the transform and executes the returned matrix" do
+    it 'passes the transform and executes the returned matrix' do
       expect(element).to receive(:parse_transform_attribute).with(transform).and_return([1, 2, 3, 4, 5, 6])
       expect(element).to receive(:add_call_and_enter).with('transformation_matrix', 1, 2, 3, 4, 5, 6)
 
@@ -28,10 +28,10 @@ describe Prawn::SVG::Attributes::Transform do
     end
   end
 
-  context "when an identity matrix is requested" do
+  context 'when an identity matrix is requested' do
     let(:transform) { 'translate(0)' }
 
-    it "does not execute any commands" do
+    it 'does not execute any commands' do
       expect(element).to receive(:parse_transform_attribute).with(transform).and_return([1, 0, 0, 1, 0, 0])
       expect(element).not_to receive(:add_call_and_enter)
 
@@ -40,8 +40,8 @@ describe Prawn::SVG::Attributes::Transform do
     end
   end
 
-  context "when transform is blank" do
-    it "does nothing" do
+  context 'when transform is blank' do
+    it 'does nothing' do
       expect(element).not_to receive(:parse_transform_attribute)
       expect(element).not_to receive(:add_call_and_enter)
 

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