chunky_png 1.3.10 → 1.3.13

data/spec/chunky_png/datastream_spec.rb

@@ -1,16 +1,14 @@
-# coding: utf-8
-require 'spec_helper'
+require "spec_helper"
 
 describe ChunkyPNG::Datastream do
-
-  describe '.from_io'do
+  describe ".from_io" do
     it "should raise an error when loading a file with a bad signature" do
-      filename = resource_file('damaged_signature.png')
+      filename = resource_file("damaged_signature.png")
       expect { ChunkyPNG::Datastream.from_file(filename) }.to raise_error(ChunkyPNG::SignatureMismatch)
     end
 
     it "should raise an error if the CRC of a chunk is incorrect" do
-      filename = resource_file('damaged_chunk.png')
+      filename = resource_file("damaged_chunk.png")
       expect { ChunkyPNG::Datastream.from_file(filename) }.to raise_error(ChunkyPNG::CRCMismatch)
     end
 
@@ -20,31 +18,37 @@ describe ChunkyPNG::Datastream do
     end
 
     it "should read a stream with trailing data without failing" do
-      filename = resource_file('trailing_bytes_after_iend_chunk.png')
+      filename = resource_file("trailing_bytes_after_iend_chunk.png")
       image = ChunkyPNG::Datastream.from_file(filename)
       expect(image).to be_instance_of(ChunkyPNG::Datastream)
     end
   end
 
-  describe '#metadata' do
+  describe "#metadata" do
     it "should load uncompressed tXTt chunks correctly" do
-      filename = resource_file('text_chunk.png')
+      filename = resource_file("text_chunk.png")
       ds = ChunkyPNG::Datastream.from_file(filename)
-      expect(ds.metadata['Title']).to  eql 'My amazing icon!'
-      expect(ds.metadata['Author']).to eql "Willem van Bergen"
+      expect(ds.metadata["Title"]).to  eql "My amazing icon!"
+      expect(ds.metadata["Author"]).to eql "Willem van Bergen"
     end
 
     it "should load compressed zTXt chunks correctly" do
-      filename = resource_file('ztxt_chunk.png')
+      filename = resource_file("ztxt_chunk.png")
       ds = ChunkyPNG::Datastream.from_file(filename)
-      expect(ds.metadata['Title']).to eql 'PngSuite'
-      expect(ds.metadata['Copyright']).to eql "Copyright Willem van Schaik, Singapore 1995-96"
+      expect(ds.metadata["Title"]).to eql "PngSuite"
+      expect(ds.metadata["Copyright"]).to eql "Copyright Willem van Schaik, Singapore 1995-96"
+    end
+
+    it "ignores iTXt chunks" do
+      filename = resource_file("itxt_chunk.png")
+      ds = ChunkyPNG::Datastream.from_file(filename)
+      expect(ds.metadata).to be_empty
     end
   end
 
-  describe '#physical_chunk' do
-    it 'should read and write pHYs chunks correctly' do
-      filename = resource_file('clock.png')
+  describe "#physical_chunk" do
+    it "should read and write pHYs chunks correctly" do
+      filename = resource_file("clock.png")
       ds = ChunkyPNG::Datastream.from_file(filename)
       expect(ds.physical_chunk.unit).to eql :meters
       expect(ds.physical_chunk.dpix.round).to eql 72
@@ -53,83 +57,83 @@ describe ChunkyPNG::Datastream do
       expect(ds.physical_chunk).not_to be_nil
     end
 
-    it 'should raise ChunkyPNG::UnitsUnknown if we request dpi but the units are unknown' do
+    it "should raise ChunkyPNG::UnitsUnknown if we request dpi but the units are unknown" do
       physical_chunk = ChunkyPNG::Chunk::Physical.new(2835, 2835, :unknown)
-      expect{physical_chunk.dpix}.to raise_error(ChunkyPNG::UnitsUnknown)
-      expect{physical_chunk.dpiy}.to raise_error(ChunkyPNG::UnitsUnknown)
+      expect { physical_chunk.dpix }.to raise_error(ChunkyPNG::UnitsUnknown)
+      expect { physical_chunk.dpiy }.to raise_error(ChunkyPNG::UnitsUnknown)
     end
   end
 
-  describe '#iTXt_chunk' do
-    it 'should read iTXt chunks correctly' do
-      filename = resource_file('itxt_chunk.png')
+  describe "#iTXt_chunk" do
+    it "should read iTXt chunks correctly" do
+      filename = resource_file("itxt_chunk.png")
       ds = ChunkyPNG::Datastream.from_file(filename)
       int_text_chunks = ds.chunks.select { |chunk| chunk.is_a?(ChunkyPNG::Chunk::InternationalText) }
       expect(int_text_chunks.length).to eq(2)
 
-      coach_uk = int_text_chunks.find { |chunk| chunk.language_tag == 'en-gb' }
-      coach_us = int_text_chunks.find { |chunk| chunk.language_tag == 'en-us' }
+      coach_uk = int_text_chunks.find { |chunk| chunk.language_tag == "en-gb" }
+      coach_us = int_text_chunks.find { |chunk| chunk.language_tag == "en-us" }
       expect(coach_uk).to_not be_nil
       expect(coach_us).to_not be_nil
 
-      expect(coach_uk.keyword).to eq('coach')
-      expect(coach_uk.text).to eq('bus with of higher standard of comfort, usually chartered or used for longer journeys')
-      expect(coach_uk.translated_keyword).to eq('bus')
+      expect(coach_uk.keyword).to eq("coach")
+      expect(coach_uk.text).to eq("bus with of higher standard of comfort, usually chartered or used for longer journeys")
+      expect(coach_uk.translated_keyword).to eq("bus")
       expect(coach_uk.compressed).to eq(ChunkyPNG::UNCOMPRESSED_CONTENT)
       expect(coach_uk.compression).to eq(ChunkyPNG::COMPRESSION_DEFAULT)
 
-      expect(coach_us.keyword).to eq('coach')
-      expect(coach_us.text).to eq('US extracurricular sports teacher at a school (UK: PE teacher) lowest class on a passenger aircraft (UK: economy)')
-      expect(coach_us.translated_keyword).to eq('trainer')
+      expect(coach_us.keyword).to eq("coach")
+      expect(coach_us.text).to eq("US extracurricular sports teacher at a school (UK: PE teacher) lowest class on a passenger aircraft (UK: economy)")
+      expect(coach_us.translated_keyword).to eq("trainer")
       expect(coach_us.compressed).to eq(ChunkyPNG::COMPRESSED_CONTENT)
       expect(coach_us.compression).to eq(ChunkyPNG::COMPRESSION_DEFAULT)
     end
 
-    it 'should write iTXt chunks correctly' do
-      expected_hex = %w(0000 001d 6954 5874 436f 6d6d 656e 7400 0000 0000 4372 6561 7465 6420 7769 7468 2047 494d 5064 2e65 07).join('')
+    it "should write iTXt chunks correctly" do
+      expected_hex = %w[0000 001d 6954 5874 436f 6d6d 656e 7400 0000 0000 4372 6561 7465 6420 7769 7468 2047 494d 5064 2e65 07].join("")
       stream = StringIO.new
-      itext = ChunkyPNG::Chunk::InternationalText.new('Comment', 'Created with GIMP')
+      itext = ChunkyPNG::Chunk::InternationalText.new("Comment", "Created with GIMP")
       itext.write(stream)
-      generated_hex = stream.string.unpack('H*').join('')
+      generated_hex = stream.string.unpack("H*").join("")
 
       expect(generated_hex).to eq(expected_hex)
     end
 
-    it 'should handle incorrect UTF-8 encoding in iTXt chunks' do
-      incorrect_text_encoding = [0, 0, 0, 14, 105, 84, 88, 116, 67, 111, 109, 109, 101, 110, 116, 0, 0, 0, 0, 0, 195, 40, 17, 87, 97, 213].pack('C*')
-      incorrect_translated_keyword_encoding = [0, 0, 0, 19, 105, 84, 88, 116, 67, 111, 109, 109, 101, 110, 116, 0, 0, 0, 0, 226, 130, 40, 0, 116, 101, 115, 116, 228, 53, 113, 182].pack('C*')
+    it "should handle incorrect UTF-8 encoding in iTXt chunks" do
+      incorrect_text_encoding = [0, 0, 0, 14, 105, 84, 88, 116, 67, 111, 109, 109, 101, 110, 116, 0, 0, 0, 0, 0, 195, 40, 17, 87, 97, 213].pack("C*")
+      incorrect_translated_keyword_encoding = [0, 0, 0, 19, 105, 84, 88, 116, 67, 111, 109, 109, 101, 110, 116, 0, 0, 0, 0, 226, 130, 40, 0, 116, 101, 115, 116, 228, 53, 113, 182].pack("C*")
 
       expect { ChunkyPNG::Chunk.read(StringIO.new(incorrect_text_encoding)) }.to raise_error(ChunkyPNG::InvalidUTF8)
       expect { ChunkyPNG::Chunk.read(StringIO.new(incorrect_translated_keyword_encoding)) }.to raise_error(ChunkyPNG::InvalidUTF8)
     end
 
-    it 'should handle UTF-8 in iTXt compressed chunks correctly' do
-      parsed = serialized_chunk(ChunkyPNG::Chunk::InternationalText.new('Comment', '✨', '', '💩', ChunkyPNG::COMPRESSED_CONTENT))
+    it "should handle UTF-8 in iTXt compressed chunks correctly" do
+      parsed = serialized_chunk(ChunkyPNG::Chunk::InternationalText.new("Comment", "✨", "", "💩", ChunkyPNG::COMPRESSED_CONTENT))
 
-      expect(parsed.text).to eq('✨')
+      expect(parsed.text).to eq("✨")
       expect(parsed.text.encoding).to eq(Encoding::UTF_8)
 
-      expect(parsed.translated_keyword).to eq('💩')
+      expect(parsed.translated_keyword).to eq("💩")
       expect(parsed.translated_keyword.encoding).to eq(Encoding::UTF_8)
     end
 
-    it 'should handle UTF-8 in iTXt chunks correctly' do
-      parsed = serialized_chunk(ChunkyPNG::Chunk::InternationalText.new('Comment', '✨', '', '💩'))
+    it "should handle UTF-8 in iTXt chunks correctly" do
+      parsed = serialized_chunk(ChunkyPNG::Chunk::InternationalText.new("Comment", "✨", "", "💩"))
 
-      expect(parsed.text).to eq('✨')
+      expect(parsed.text).to eq("✨")
       expect(parsed.text.encoding).to eq(Encoding::UTF_8)
-      
-      expect(parsed.translated_keyword).to eq('💩')      
+
+      expect(parsed.translated_keyword).to eq("💩")
       expect(parsed.translated_keyword.encoding).to eq(Encoding::UTF_8)
     end
 
-    it 'should transform non UTF-8 iTXt fields to UTF-8 on write' do
-      parsed = serialized_chunk(ChunkyPNG::Chunk::InternationalText.new('Comment', '®'.encode('Windows-1252'), '', 'ƒ'.encode('Windows-1252')))
+    it "should transform non UTF-8 iTXt fields to UTF-8 on write" do
+      parsed = serialized_chunk(ChunkyPNG::Chunk::InternationalText.new("Comment", "®".encode("Windows-1252"), "", "ƒ".encode("Windows-1252")))
 
-      expect(parsed.text).to eq('®')
+      expect(parsed.text).to eq("®")
       expect(parsed.text.encoding).to eq(Encoding::UTF_8)
 
-      expect(parsed.translated_keyword).to eq('ƒ')
+      expect(parsed.translated_keyword).to eq("ƒ")
       expect(parsed.translated_keyword.encoding).to eq(Encoding::UTF_8)
     end
   end

data/spec/chunky_png/dimension_spec.rb

@@ -1,4 +1,4 @@
-require 'spec_helper'
+require "spec_helper"
 
 describe ChunkyPNG::Dimension do
   subject { ChunkyPNG::Dimension.new(2, 3) }
@@ -6,31 +6,31 @@ describe ChunkyPNG::Dimension do
   it { should respond_to(:width) }
   it { should respond_to(:height) }
 
-  describe '#area' do
+  describe "#area" do
     it "should calculate the area correctly" do
       expect(subject.area).to eql 6
     end
   end
 end
 
-describe 'ChunkyPNG.Dimension' do
+describe "ChunkyPNG.Dimension" do
   subject { ChunkyPNG::Dimension.new(1, 2) }
 
   it "should create a dimension from a 2-item array" do
     expect(ChunkyPNG::Dimension([1, 2])).to     eql subject
-    expect(ChunkyPNG::Dimension(['1', '2'])).to eql subject
+    expect(ChunkyPNG::Dimension(["1", "2"])).to eql subject
   end
 
-  it "should create a dimension from a hash with x and y keys" do
-    expect(ChunkyPNG::Dimension(:width => 1, :height => 2)).to       eql subject
-    expect(ChunkyPNG::Dimension('width' => '1', 'height' => '2')).to eql subject
+  it "should create a dimension from a hash with width and height keys" do
+    expect(ChunkyPNG::Dimension(width: 1, height: 2)).to eql subject
+    expect(ChunkyPNG::Dimension("width" => "1", "height" => "2")).to eql subject
   end
 
   it "should create a dimension from a point-like string" do
     [
-      ChunkyPNG::Dimension('1,2'),
-      ChunkyPNG::Dimension('1   2'),
-      ChunkyPNG::Dimension('(1 , 2)'),
+      ChunkyPNG::Dimension("1,2"),
+      ChunkyPNG::Dimension("1   2"),
+      ChunkyPNG::Dimension("(1 , 2)"),
       ChunkyPNG::Dimension("{1x2}"),
       ChunkyPNG::Dimension("[1\t2}"),
     ].all? { |point| point == subject }

data/spec/chunky_png/image_spec.rb

@@ -1,31 +1,28 @@
-require 'spec_helper'
+require "spec_helper"
 
 describe ChunkyPNG::Image do
-  describe '#metadata' do
-
+  describe "#metadata" do
     it "should load metadata from an existing file" do
-      image = ChunkyPNG::Image.from_file(resource_file('text_chunk.png'))
-      expect(image.metadata['Title']).to  eql 'My amazing icon!'
-      expect(image.metadata['Author']).to eql 'Willem van Bergen'
+      image = ChunkyPNG::Image.from_file(resource_file("text_chunk.png"))
+      expect(image.metadata["Title"]).to  eql "My amazing icon!"
+      expect(image.metadata["Author"]).to eql "Willem van Bergen"
     end
 
     it "should write metadata to the file correctly" do
-      filename = resource_file('_metadata.png')
+      filename = resource_file("_metadata.png")
 
       image = ChunkyPNG::Image.new(10, 10)
-      image.metadata['Title']  = 'My amazing icon!'
-      image.metadata['Author'] = 'Willem van Bergen'
+      image.metadata["Title"]  = "My amazing icon!"
+      image.metadata["Author"] = "Willem van Bergen"
       image.save(filename)
 
       metadata = ChunkyPNG::Datastream.from_file(filename).metadata
-      expect(metadata['Title']).to  eql 'My amazing icon!'
-      expect(metadata['Author']).to eql 'Willem van Bergen'
+      expect(metadata["Title"]).to  eql "My amazing icon!"
+      expect(metadata["Author"]).to eql "Willem van Bergen"
     end
 
     it "should load empty images correctly" do
-      expect do
-        ChunkyPNG::Image.from_file(resource_file('empty.png'))
-      end.to_not raise_error
+      expect { ChunkyPNG::Image.from_file(resource_file("empty.png")) }.to_not raise_error
     end
   end
 end

data/spec/chunky_png/point_spec.rb

@@ -1,58 +1,56 @@
-require 'spec_helper'
+require "spec_helper"
 
 describe ChunkyPNG::Point do
-
   subject { ChunkyPNG::Point.new(1, 2) }
 
   it { should respond_to(:x) }
   it { should respond_to(:y) }
 
-  describe '#within_bounds?' do
+  describe "#within_bounds?" do
     it { should     be_within_bounds(2, 3)  }
-    it { should_not be_within_bounds('1x3') }
+    it { should_not be_within_bounds("1x3") }
     it { should_not be_within_bounds(2, 2) }
-    it { should_not be_within_bounds('[1 2]') }
+    it { should_not be_within_bounds("[1 2]") }
   end
 
-  describe '#<=>' do
+  describe "#<=>" do
     it "should return 0 if the coordinates are identical" do
-      expect((subject <=> ChunkyPNG::Point.new(1, 2))).to eql 0
+      expect((subject <=> ChunkyPNG::Point.new(1, 2))).to eql(0)
     end
 
     it "should return -1 if the y coordinate is smaller than the other one" do
-      expect((subject <=> ChunkyPNG::Point.new(1, 3))).to eql -1
-      expect((subject <=> ChunkyPNG::Point.new(0, 3))).to eql -1 # x doesn't matter
-      expect((subject <=> ChunkyPNG::Point.new(2, 3))).to eql -1 # x doesn't matter
+      expect((subject <=> ChunkyPNG::Point.new(1, 3))).to eql(-1)
+      expect((subject <=> ChunkyPNG::Point.new(0, 3))).to eql(-1) # x doesn't matter
+      expect((subject <=> ChunkyPNG::Point.new(2, 3))).to eql(-1) # x doesn't matter
     end
 
     it "should return 1 if the y coordinate is larger than the other one" do
-      expect((subject <=> ChunkyPNG::Point.new(1, 0))).to eql 1
-      expect((subject <=> ChunkyPNG::Point.new(0, 0))).to eql 1 # x doesn't matter
-      expect((subject <=> ChunkyPNG::Point.new(2, 0))).to eql 1 # x doesn't matter
+      expect((subject <=> ChunkyPNG::Point.new(1, 0))).to eql(1)
+      expect((subject <=> ChunkyPNG::Point.new(0, 0))).to eql(1) # x doesn't matter
+      expect((subject <=> ChunkyPNG::Point.new(2, 0))).to eql(1) # x doesn't matter
     end
 
     it "should return -1 if the x coordinate is smaller and y is the same" do
-      expect((subject <=> ChunkyPNG::Point.new(2, 2))).to eql -1
+      expect((subject <=> ChunkyPNG::Point.new(2, 2))).to eql(-1)
     end
 
     it "should return 1 if the x coordinate is larger and y is the same" do
-      expect((subject <=> ChunkyPNG::Point.new(0, 2))).to eql 1
+      expect((subject <=> ChunkyPNG::Point.new(0, 2))).to eql(1)
     end
   end
 end
 
-describe 'ChunkyPNG.Point' do
+describe "ChunkyPNG.Point" do
   subject { ChunkyPNG::Point.new(1, 2) }
 
-
   it "should create a point from a 2-item array" do
     expect(ChunkyPNG::Point([1, 2])).to     eql subject
-    expect(ChunkyPNG::Point(['1', '2'])).to eql subject
+    expect(ChunkyPNG::Point(["1", "2"])).to eql subject
   end
 
   it "should create a point from a hash with x and y keys" do
-    expect(ChunkyPNG::Point(:x => 1, :y => 2)).to       eql subject
-    expect(ChunkyPNG::Point('x' => '1', 'y' => '2')).to eql subject
+    expect(ChunkyPNG::Point(x: 1, y: 2)).to             eql subject
+    expect(ChunkyPNG::Point("x" => "1", "y" => "2")).to eql subject
   end
 
   it "should create a point from a ChunkyPNG::Dimension object" do
@@ -62,9 +60,9 @@ describe 'ChunkyPNG.Point' do
 
   it "should create a point from a point-like string" do
     [
-      ChunkyPNG::Point('1,2'),
-      ChunkyPNG::Point('1   2'),
-      ChunkyPNG::Point('(1 , 2)'),
+      ChunkyPNG::Point("1,2"),
+      ChunkyPNG::Point("1   2"),
+      ChunkyPNG::Point("(1 , 2)"),
       ChunkyPNG::Point("{1,\t2}"),
       ChunkyPNG::Point("[1 2}"),
     ].all? { |point| point == subject }

data/spec/chunky_png/rmagick_spec.rb

@@ -1,23 +1,22 @@
-require 'spec_helper'
+require "spec_helper"
 
 begin
-  require 'chunky_png/rmagick'
+  require "chunky_png/rmagick"
 
   describe ChunkyPNG::RMagick do
-
     it "should import an image from RMagick correctly" do
-      image = Magick::Image.read(resource_file('composited.png')).first
+      image = Magick::Image.read(resource_file("composited.png")).first
       canvas = ChunkyPNG::RMagick.import(image)
-      expect(canvas).to eql reference_canvas('composited')
+      expect(canvas).to eql reference_canvas("composited")
     end
 
     it "should export an image to RMagick correctly" do
-      canvas = reference_canvas('composited')
+      canvas = reference_canvas("composited")
       image  = ChunkyPNG::RMagick.export(canvas)
-      image.format = 'PNG32'
+      image.format = "PNG32"
       expect(canvas).to eql ChunkyPNG::Canvas.from_blob(image.to_blob)
     end
   end
-rescue LoadError => e
+rescue LoadError
   # skipping RMagick tests
 end

data/spec/chunky_png/vector_spec.rb

@@ -1,17 +1,17 @@
-require 'spec_helper'
+require "spec_helper"
 
 describe ChunkyPNG::Vector do
   subject { ChunkyPNG::Vector.new([ChunkyPNG::Point.new(2, 5), ChunkyPNG::Point.new(1, 3), ChunkyPNG::Point.new(4, 6)]) }
 
   it { should respond_to(:points) }
 
-  describe '#length' do
+  describe "#length" do
     it "shopuld have 3 items" do
       expect(subject.length).to eql(3)
     end
   end
 
-  describe '#x_range' do
+  describe "#x_range" do
     it "should get the right range of x values" do
       expect(subject.x_range).to eql(1..4)
     end
@@ -29,7 +29,7 @@ describe ChunkyPNG::Vector do
     end
   end
 
-  describe '#y_range' do
+  describe "#y_range" do
     it "should get the right range of y values" do
       expect(subject.y_range).to eql(3..6)
     end
@@ -47,7 +47,7 @@ describe ChunkyPNG::Vector do
     end
   end
 
-  describe '#offset' do
+  describe "#offset" do
     it "should return a ChunkyPNG::Point" do
       expect(subject.offset).to be_kind_of(ChunkyPNG::Point)
     end
@@ -58,7 +58,7 @@ describe ChunkyPNG::Vector do
     end
   end
 
-  describe '#dimension' do
+  describe "#dimension" do
     it "should return a ChunkyPNG::Dimension" do
       expect(subject.dimension).to be_kind_of(ChunkyPNG::Dimension)
     end
@@ -69,26 +69,30 @@ describe ChunkyPNG::Vector do
     end
   end
 
-  describe '#edges' do
+  describe "#edges" do
     it "should get three edges when closing the path" do
-      expect(subject.edges(true).to_a).to eql [[ChunkyPNG::Point.new(2, 5), ChunkyPNG::Point.new(1, 3)],
-                                          [ChunkyPNG::Point.new(1, 3), ChunkyPNG::Point.new(4, 6)],
-                                          [ChunkyPNG::Point.new(4, 6), ChunkyPNG::Point.new(2, 5)]]
+      expect(subject.edges(true).to_a).to eql [
+        [ChunkyPNG::Point.new(2, 5), ChunkyPNG::Point.new(1, 3)],
+        [ChunkyPNG::Point.new(1, 3), ChunkyPNG::Point.new(4, 6)],
+        [ChunkyPNG::Point.new(4, 6), ChunkyPNG::Point.new(2, 5)],
+      ]
     end
 
     it "should get two edges when not closing the path" do
-      expect(subject.edges(false).to_a).to eql [[ChunkyPNG::Point.new(2, 5), ChunkyPNG::Point.new(1, 3)],
-                                           [ChunkyPNG::Point.new(1, 3), ChunkyPNG::Point.new(4, 6)]]
+      expect(subject.edges(false).to_a).to eql [
+        [ChunkyPNG::Point.new(2, 5), ChunkyPNG::Point.new(1, 3)],
+        [ChunkyPNG::Point.new(1, 3), ChunkyPNG::Point.new(4, 6)],
+      ]
     end
   end
 end
 
-describe 'ChunkyPNG.Vector' do
+describe "ChunkyPNG.Vector" do
   let(:example) { ChunkyPNG::Vector.new([ChunkyPNG::Point.new(2, 4), ChunkyPNG::Point.new(1, 2), ChunkyPNG::Point.new(3, 6)]) }
 
   it "should return an empty vector when given an empty array" do
     expect(ChunkyPNG::Vector()).to eql ChunkyPNG::Vector.new([])
-    expect(ChunkyPNG::Vector(*[])).to eql ChunkyPNG::Vector.new([])
+    expect(ChunkyPNG::Vector(*[])).to eql ChunkyPNG::Vector.new([]) # rubocop:disable Lint/UnneededSplatExpansion
   end
 
   it "should raise an error when an odd number of numerics is given" do
@@ -96,14 +100,14 @@ describe 'ChunkyPNG.Vector' do
   end
 
   it "should create a vector from a string" do
-    expect(ChunkyPNG::Vector('(2,4) (1,2) (3,6)')).to eql example
+    expect(ChunkyPNG::Vector("(2,4) (1,2) (3,6)")).to eql example
   end
 
   it "should create a vector from a flat array" do
-    expect(ChunkyPNG::Vector(2,4,1,2,3,6)).to eql example
+    expect(ChunkyPNG::Vector(2, 4, 1, 2, 3, 6)).to eql example
   end
 
   it "should create a vector from a nested array" do
-    expect(ChunkyPNG::Vector('(2,4)', [1, 2], :x => 3, :y => 6)).to eql example
+    expect(ChunkyPNG::Vector("(2,4)", [1, 2], x: 3, y: 6)).to eql example
   end
 end