chunky_png 1.3.9 → 1.3.12

data/spec/chunky_png/canvas/masking_spec.rb

@@ -1,41 +1,40 @@
-require 'spec_helper'
+require "spec_helper"
 
 describe ChunkyPNG::Canvas::Masking do
-
-  subject { reference_canvas('clock') }
+  subject { reference_canvas("clock") }
 
   before(:all) do
-    @theme_color      = ChunkyPNG::Color('#e10f7a')
-    @new_color        = ChunkyPNG::Color('#ff0000')
-    @background_color = ChunkyPNG::Color('white')
+    @theme_color      = ChunkyPNG::Color("#e10f7a")
+    @new_color        = ChunkyPNG::Color("#ff0000")
+    @background_color = ChunkyPNG::Color("white")
   end
 
-  describe '#change_theme_color!' do
+  describe "#change_theme_color!" do
     it "should change the theme color correctly" do
       subject.change_theme_color!(@theme_color, @new_color)
-      expect(subject).to eql reference_canvas('clock_updated')
+      expect(subject).to eql reference_canvas("clock_updated")
     end
   end
 
-  describe '#extract_mask' do
+  describe "#extract_mask" do
     it "should create the correct base and mask image" do
       base, mask = subject.extract_mask(@theme_color, @background_color)
-      expect(base).to eql reference_canvas('clock_base')
-      expect(mask).to eql reference_canvas('clock_mask')
+      expect(base).to eql reference_canvas("clock_base")
+      expect(mask).to eql reference_canvas("clock_mask")
     end
 
     it "should create a mask image with only one opaque color" do
-      base, mask = subject.extract_mask(@theme_color, @background_color)
+      _, mask = subject.extract_mask(@theme_color, @background_color)
       expect(mask.palette.opaque_palette.size).to eql 1
     end
   end
 
-  describe '#change_mask_color!' do
-    before { @mask = reference_canvas('clock_mask') }
+  describe "#change_mask_color!" do
+    before { @mask = reference_canvas("clock_mask") }
 
     it "should replace the mask color correctly" do
       @mask.change_mask_color!(@new_color)
-      expect(@mask).to eql reference_canvas('clock_mask_updated')
+      expect(@mask).to eql reference_canvas("clock_mask_updated")
     end
 
     it "should still only have one opaque color" do
@@ -44,7 +43,7 @@ describe ChunkyPNG::Canvas::Masking do
     end
 
     it "should raise an exception when the mask image has more than once color" do
-      not_a_mask = reference_canvas('operations')
+      not_a_mask = reference_canvas("operations")
       expect { not_a_mask.change_mask_color!(@new_color) }.to raise_error(ChunkyPNG::ExpectationFailed)
     end
   end

data/spec/chunky_png/canvas/operations_spec.rb

@@ -1,16 +1,15 @@
-require 'spec_helper'
+require "spec_helper"
 
 describe ChunkyPNG::Canvas::Operations do
+  subject { reference_canvas("operations") }
 
-  subject { reference_canvas('operations') }
-
-  describe '#grayscale' do
+  describe "#grayscale" do
     it "should not return itself" do
       subject.grayscale.should_not equal(subject)
     end
 
     it "should convert the image correctly" do
-      expect(subject.grayscale).to eql reference_canvas('operations_grayscale')
+      expect(subject.grayscale).to eql reference_canvas("operations_grayscale")
     end
 
     it "should not adjust the current image" do
@@ -18,20 +17,20 @@ describe ChunkyPNG::Canvas::Operations do
     end
   end
 
-  describe '#grayscale!' do
+  describe "#grayscale!" do
     it "should return itself" do
       expect(subject.grayscale!).to equal(subject)
     end
 
     it "should convert the image correctly" do
       subject.grayscale!
-      expect(subject).to eql reference_canvas('operations_grayscale')
+      expect(subject).to eql reference_canvas("operations_grayscale")
     end
   end
 
-  describe '#crop' do
+  describe "#crop" do
     it "should crop the right pixels from the original canvas" do
-      expect(subject.crop(10, 5, 4, 8)).to eql reference_canvas('cropped')
+      expect(subject.crop(10, 5, 4, 8)).to eql reference_canvas("cropped")
     end
 
     it "should not return itself" do
@@ -47,18 +46,19 @@ describe ChunkyPNG::Canvas::Operations do
     end
   end
 
-  describe '#crop!' do
-    context 'when cropping both width and height' do
+  describe "#crop!" do
+    context "when cropping both width and height" do
       let(:crop_opts) { [10, 5, 4, 8] }
 
       it "should crop the right pixels from the original canvas" do
         subject.crop!(*crop_opts)
-        expect(subject).to eql reference_canvas('cropped')
+        expect(subject).to eql reference_canvas("cropped")
       end
 
       it "should have a new width and height" do
-        expect { subject.crop!(*crop_opts) }.to change { subject.dimension }.
-            from(ChunkyPNG::Dimension('16x16')).to(ChunkyPNG::Dimension('4x8'))
+        expect { subject.crop!(*crop_opts) }.to change { subject.dimension }
+          .from(ChunkyPNG::Dimension("16x16"))
+          .to(ChunkyPNG::Dimension("4x8"))
       end
 
       it "should return itself" do
@@ -71,12 +71,13 @@ describe ChunkyPNG::Canvas::Operations do
 
       it "should crop the right pixels from the original canvas" do
         subject.crop!(*crop_opts)
-        expect(subject).to eql reference_canvas('cropped_height')
+        expect(subject).to eql reference_canvas("cropped_height")
       end
 
       it "should have a new width and height" do
-        expect { subject.crop!(*crop_opts) }.to change { subject.dimension }.
-            from(ChunkyPNG::Dimension('16x16')).to(ChunkyPNG::Dimension('16x8'))
+        expect { subject.crop!(*crop_opts) }.to change { subject.dimension }
+          .from(ChunkyPNG::Dimension("16x16"))
+          .to(ChunkyPNG::Dimension("16x8"))
       end
 
       it "should return itself" do
@@ -91,91 +92,90 @@ describe ChunkyPNG::Canvas::Operations do
     end
   end
 
-  describe '#compose' do
+  describe "#compose" do
     it "should compose pixels correctly" do
       subcanvas = ChunkyPNG::Canvas.new(4, 8, ChunkyPNG::Color.rgba(0, 0, 0, 75))
-      expect(subject.compose(subcanvas, 8, 4)).to eql reference_canvas('composited')
+      expect(subject.compose(subcanvas, 8, 4)).to eql reference_canvas("composited")
     end
 
     it "should leave the original intact" do
-      subject.compose(ChunkyPNG::Canvas.new(1,1))
-      expect(subject).to eql reference_canvas('operations')
+      subject.compose(ChunkyPNG::Canvas.new(1, 1))
+      expect(subject).to eql reference_canvas("operations")
     end
 
     it "should not return itself" do
-      subject.compose(ChunkyPNG::Canvas.new(1,1)).should_not equal(subject)
+      subject.compose(ChunkyPNG::Canvas.new(1, 1)).should_not equal(subject)
     end
 
     it "should raise an exception when the pixels to compose fall outside the image" do
-      expect { subject.compose(ChunkyPNG::Canvas.new(1,1), 16, 16) }.to raise_error(ChunkyPNG::OutOfBounds)
+      expect { subject.compose(ChunkyPNG::Canvas.new(1, 1), 16, 16) }.to raise_error(ChunkyPNG::OutOfBounds)
     end
   end
 
-  describe '#compose!' do
+  describe "#compose!" do
     it "should compose pixels correctly" do
       subcanvas = ChunkyPNG::Canvas.new(4, 8, ChunkyPNG::Color.rgba(0, 0, 0, 75))
       subject.compose!(subcanvas, 8, 4)
-      expect(subject).to eql reference_canvas('composited')
+      expect(subject).to eql reference_canvas("composited")
     end
 
     it "should return itself" do
-      expect(subject.compose!(ChunkyPNG::Canvas.new(1,1))).to equal(subject)
+      expect(subject.compose!(ChunkyPNG::Canvas.new(1, 1))).to equal(subject)
     end
 
     it "should compose a base image and mask correctly" do
-      base = reference_canvas('clock_base')
-      mask = reference_canvas('clock_mask_updated')
+      base = reference_canvas("clock_base")
+      mask = reference_canvas("clock_mask_updated")
       base.compose!(mask)
-      expect(base).to eql reference_canvas('clock_updated')
+      expect(base).to eql reference_canvas("clock_updated")
     end
 
     it "should raise an exception when the pixels to compose fall outside the image" do
-      expect { subject.compose!(ChunkyPNG::Canvas.new(1,1), 16, 16) }.to raise_error(ChunkyPNG::OutOfBounds)
+      expect { subject.compose!(ChunkyPNG::Canvas.new(1, 1), 16, 16) }.to raise_error(ChunkyPNG::OutOfBounds)
     end
   end
 
-  describe '#replace' do
+  describe "#replace" do
     it "should replace the correct pixels" do
       subcanvas = ChunkyPNG::Canvas.new(3, 2, ChunkyPNG::Color.rgb(200, 255, 0))
-      expect(subject.replace(subcanvas, 5, 4)).to eql reference_canvas('replaced')
+      expect(subject.replace(subcanvas, 5, 4)).to eql reference_canvas("replaced")
     end
 
     it "should not return itself" do
-      subject.replace(ChunkyPNG::Canvas.new(1,1)).should_not equal(subject)
+      subject.replace(ChunkyPNG::Canvas.new(1, 1)).should_not equal(subject)
     end
 
     it "should leave the original intact" do
-      subject.replace(ChunkyPNG::Canvas.new(1,1))
-      expect(subject).to eql reference_canvas('operations')
+      subject.replace(ChunkyPNG::Canvas.new(1, 1))
+      expect(subject).to eql reference_canvas("operations")
     end
 
     it "should raise an exception when the pixels to replace fall outside the image" do
-      expect { subject.replace(ChunkyPNG::Canvas.new(1,1), 16, 16) }.to raise_error(ChunkyPNG::OutOfBounds)
+      expect { subject.replace(ChunkyPNG::Canvas.new(1, 1), 16, 16) }.to raise_error(ChunkyPNG::OutOfBounds)
     end
   end
 
-  describe '#replace!' do
+  describe "#replace!" do
     it "should replace the correct pixels" do
       subcanvas = ChunkyPNG::Canvas.new(3, 2, ChunkyPNG::Color.rgb(200, 255, 0))
       subject.replace!(subcanvas, 5, 4)
-      expect(subject).to eql reference_canvas('replaced')
+      expect(subject).to eql reference_canvas("replaced")
     end
 
     it "should return itself" do
-      expect(subject.replace!(ChunkyPNG::Canvas.new(1,1))).to equal(subject)
+      expect(subject.replace!(ChunkyPNG::Canvas.new(1, 1))).to equal(subject)
     end
 
     it "should raise an exception when the pixels to replace fall outside the image" do
-      expect { subject.replace!(ChunkyPNG::Canvas.new(1,1), 16, 16) }.to raise_error(ChunkyPNG::OutOfBounds)
+      expect { subject.replace!(ChunkyPNG::Canvas.new(1, 1), 16, 16) }.to raise_error(ChunkyPNG::OutOfBounds)
     end
   end
 end
 
 describe ChunkyPNG::Canvas::Operations do
-
   subject { ChunkyPNG::Canvas.new(2, 3, [1, 2, 3, 4, 5, 6]) }
 
-  describe '#flip_horizontally!' do
+  describe "#flip_horizontally!" do
     it "should flip the pixels horizontally in place" do
       subject.flip_horizontally!
       expect(subject).to eql ChunkyPNG::Canvas.new(2, 3, [5, 6, 3, 4, 1, 2])
@@ -186,7 +186,7 @@ describe ChunkyPNG::Canvas::Operations do
     end
   end
 
-  describe '#flip_horizontally' do
+  describe "#flip_horizontally" do
     it "should flip the pixels horizontally" do
       expect(subject.flip_horizontally).to eql ChunkyPNG::Canvas.new(2, 3, [5, 6, 3, 4, 1, 2])
     end
@@ -200,7 +200,7 @@ describe ChunkyPNG::Canvas::Operations do
     end
   end
 
-  describe '#flip_vertically!' do
+  describe "#flip_vertically!" do
     it "should flip the pixels vertically" do
       subject.flip_vertically!
       expect(subject).to eql ChunkyPNG::Canvas.new(2, 3, [2, 1, 4, 3, 6, 5])
@@ -211,7 +211,7 @@ describe ChunkyPNG::Canvas::Operations do
     end
   end
 
-  describe '#flip_vertically' do
+  describe "#flip_vertically" do
     it "should flip the pixels vertically" do
       expect(subject.flip_vertically).to eql ChunkyPNG::Canvas.new(2, 3, [2, 1, 4, 3, 6, 5])
     end
@@ -225,9 +225,9 @@ describe ChunkyPNG::Canvas::Operations do
     end
   end
 
-  describe '#rotate_left' do
+  describe "#rotate_left" do
     it "should rotate the pixels 90 degrees counter-clockwise" do
-      expect(subject.rotate_left).to eql ChunkyPNG::Canvas.new(3, 2, [2, 4, 6, 1, 3, 5] )
+      expect(subject.rotate_left).to eql ChunkyPNG::Canvas.new(3, 2, [2, 4, 6, 1, 3, 5])
     end
 
     it "should not return itself" do
@@ -251,10 +251,10 @@ describe ChunkyPNG::Canvas::Operations do
     end
   end
 
-  describe '#rotate_left!' do
+  describe "#rotate_left!" do
     it "should rotate the pixels 90 degrees clockwise" do
       subject.rotate_left!
-      expect(subject).to eql ChunkyPNG::Canvas.new(3, 2, [2, 4, 6, 1, 3, 5] )
+      expect(subject).to eql ChunkyPNG::Canvas.new(3, 2, [2, 4, 6, 1, 3, 5])
     end
 
     it "should return itself" do
@@ -262,14 +262,14 @@ describe ChunkyPNG::Canvas::Operations do
     end
 
     it "should change the image dimensions" do
-      expect { subject.rotate_left! }.to change { subject.dimension }.
-          from(ChunkyPNG::Dimension('2x3')).to(ChunkyPNG::Dimension('3x2'))
+      expect { subject.rotate_left! }.to change { subject.dimension }
+        .from(ChunkyPNG::Dimension("2x3")).to(ChunkyPNG::Dimension("3x2"))
     end
   end
 
-  describe '#rotate_right' do
+  describe "#rotate_right" do
     it "should rotate the pixels 90 degrees clockwise" do
-      expect(subject.rotate_right).to eql ChunkyPNG::Canvas.new(3, 2, [5, 3, 1, 6, 4, 2] )
+      expect(subject.rotate_right).to eql ChunkyPNG::Canvas.new(3, 2, [5, 3, 1, 6, 4, 2])
     end
 
     it "should not return itself" do
@@ -293,10 +293,10 @@ describe ChunkyPNG::Canvas::Operations do
     end
   end
 
-  describe '#rotate_right!' do
+  describe "#rotate_right!" do
     it "should rotate the pixels 90 degrees clockwise" do
       subject.rotate_right!
-      expect(subject).to eql ChunkyPNG::Canvas.new(3, 2, [5, 3, 1, 6, 4, 2] )
+      expect(subject).to eql ChunkyPNG::Canvas.new(3, 2, [5, 3, 1, 6, 4, 2])
     end
 
     it "should return itself" do
@@ -304,12 +304,13 @@ describe ChunkyPNG::Canvas::Operations do
     end
 
     it "should change the image dimensions" do
-      expect { subject.rotate_right! }.to change { subject.dimension }.
-          from(ChunkyPNG::Dimension('2x3')).to(ChunkyPNG::Dimension('3x2'))
+      expect { subject.rotate_right! }.to change { subject.dimension }
+        .from(ChunkyPNG::Dimension("2x3"))
+        .to(ChunkyPNG::Dimension("3x2"))
     end
   end
 
-  describe '#rotate_180' do
+  describe "#rotate_180" do
     it "should rotate the pixels 180 degrees" do
       expect(subject.rotate_180).to eql ChunkyPNG::Canvas.new(2, 3, [6, 5, 4, 3, 2, 1])
     end
@@ -323,7 +324,7 @@ describe ChunkyPNG::Canvas::Operations do
     end
   end
 
-  describe '#rotate_180!' do
+  describe "#rotate_180!" do
     it "should rotate the pixels 180 degrees" do
       subject.rotate_180!
       expect(subject).to eql ChunkyPNG::Canvas.new(2, 3, [6, 5, 4, 3, 2, 1])
@@ -336,7 +337,6 @@ describe ChunkyPNG::Canvas::Operations do
 end
 
 describe ChunkyPNG::Canvas::Operations do
-
   subject { ChunkyPNG::Canvas.new(4, 4).rect(1, 1, 2, 2, 255, 255) }
 
   describe "#trim" do
@@ -368,19 +368,19 @@ describe ChunkyPNG::Canvas::Operations do
     end
 
     it "should change the image dimensions" do
-      expect { subject.trim! }.to change { subject.dimension }.
-          from(ChunkyPNG::Dimension('4x4')).to(ChunkyPNG::Dimension('2x2'))
+      expect { subject.trim! }.to change { subject.dimension }
+        .from(ChunkyPNG::Dimension("4x4"))
+        .to(ChunkyPNG::Dimension("2x2"))
     end
   end
 end
 
 describe ChunkyPNG::Canvas::Operations do
-
   subject { ChunkyPNG::Canvas.new(4, 4) }
 
   describe "#border" do
     it "should add the border" do
-      expect(subject.border(2)).to eql reference_canvas('operations_border')
+      expect(subject.border(2)).to eql reference_canvas("operations_border")
     end
 
     it "should not return itself" do
@@ -395,7 +395,7 @@ describe ChunkyPNG::Canvas::Operations do
   describe "#border!" do
     it "should add the border" do
       subject.border!(2)
-      expect(subject).to eql reference_canvas('operations_border')
+      expect(subject).to eql reference_canvas("operations_border")
     end
 
     it "should return itself" do
@@ -408,8 +408,9 @@ describe ChunkyPNG::Canvas::Operations do
     end
 
     it "should change the image dimensions" do
-      expect { subject.border!(1) }.to change { subject.dimension }.
-          from(ChunkyPNG::Dimension('4x4')).to(ChunkyPNG::Dimension('6x6'))
+      expect { subject.border!(1) }.to change { subject.dimension }
+        .from(ChunkyPNG::Dimension("4x4"))
+        .to(ChunkyPNG::Dimension("6x6"))
     end
   end
 end

data/spec/chunky_png/canvas/png_decoding_spec.rb

@@ -1,97 +1,96 @@
-require 'spec_helper'
+require "spec_helper"
 
 describe ChunkyPNG::Canvas::PNGDecoding do
   include ChunkyPNG::Canvas::PNGDecoding
 
-  describe '#decode_png_scanline' do
-
+  describe "#decode_png_scanline" do
     it "should decode a line without filtering as is" do
-      stream = [ChunkyPNG::FILTER_NONE, 255, 255, 255, 255, 255, 255, 255, 255, 255].pack('C*')
+      stream = [ChunkyPNG::FILTER_NONE, 255, 255, 255, 255, 255, 255, 255, 255, 255].pack("C*")
       decode_png_str_scanline(stream, 0, nil, 9, 3)
-      expect(stream.unpack('@1C*')).to eql [255, 255, 255, 255, 255, 255, 255, 255, 255]
+      expect(stream.unpack("@1C*")).to eql [255, 255, 255, 255, 255, 255, 255, 255, 255]
     end
 
     it "should decode a line with sub filtering correctly" do
       # all white pixels
-      stream = [ChunkyPNG::FILTER_SUB, 255, 255, 255, 0, 0, 0, 0, 0, 0].pack('C*')
+      stream = [ChunkyPNG::FILTER_SUB, 255, 255, 255, 0, 0, 0, 0, 0, 0].pack("C*")
       decode_png_str_scanline(stream, 0, nil, 9, 3)
-      expect(stream.unpack('@1C*')).to eql [255, 255, 255, 255, 255, 255, 255, 255, 255]
+      expect(stream.unpack("@1C*")).to eql [255, 255, 255, 255, 255, 255, 255, 255, 255]
 
       # all black pixels
-      stream = [ChunkyPNG::FILTER_SUB, 0, 0, 0, 0, 0, 0, 0, 0, 0].pack('C*')
+      stream = [ChunkyPNG::FILTER_SUB, 0, 0, 0, 0, 0, 0, 0, 0, 0].pack("C*")
       decode_png_str_scanline(stream, 0, nil, 9, 3)
-      expect(stream.unpack('@1C*')).to eql [0, 0, 0, 0, 0, 0, 0, 0, 0]
+      expect(stream.unpack("@1C*")).to eql [0, 0, 0, 0, 0, 0, 0, 0, 0]
 
       # various colors
-      stream = [ChunkyPNG::FILTER_SUB, 255, 0, 45, 0, 255, 0, 112, 200, 178].pack('C*')
+      stream = [ChunkyPNG::FILTER_SUB, 255, 0, 45, 0, 255, 0, 112, 200, 178].pack("C*")
       decode_png_str_scanline(stream, 0, nil, 9, 3)
-      expect(stream.unpack('@1C*')).to eql [255, 0, 45, 255, 255, 45, 111, 199, 223]
+      expect(stream.unpack("@1C*")).to eql [255, 0, 45, 255, 255, 45, 111, 199, 223]
     end
 
     it "should decode a line with up filtering correctly" do
       # previous line has various pixels
       previous = [ChunkyPNG::FILTER_UP, 255, 255, 255, 127, 127, 127, 0, 0, 0]
       current  = [ChunkyPNG::FILTER_UP, 0, 127, 255, 0, 127, 255, 0, 127, 255]
-      stream   = (previous + current).pack('C*')
+      stream   = (previous + current).pack("C*")
       decode_png_str_scanline(stream, 10, 0, 9, 3)
-      expect(stream.unpack('@11C9')).to eql [255, 126, 254, 127, 254, 126, 0, 127, 255]
+      expect(stream.unpack("@11C9")).to eql [255, 126, 254, 127, 254, 126, 0, 127, 255]
     end
 
     it "should decode a line with average filtering correctly" do
-      previous = [ChunkyPNG::FILTER_AVERAGE, 10, 20, 30, 40, 50, 60, 70, 80, 80, 100, 110, 120]
-      current  = [ChunkyPNG::FILTER_AVERAGE,  0,  0, 10, 23, 15, 13, 23, 63, 38,  60, 253,  53]
-      stream   = (previous + current).pack('C*')
+      previous = [ChunkyPNG::FILTER_AVERAGE, 10, 20, 30, 40, 50, 60, 70, 80, 80, 100, 110, 120] # rubocop:disable Layout/ExtraSpacing
+      current  = [ChunkyPNG::FILTER_AVERAGE,  0,  0, 10, 23, 15, 13, 23, 63, 38,  60, 253,  53] # rubocop:disable Layout/ExtraSpacing
+      stream   = (previous + current).pack("C*")
       decode_png_str_scanline(stream, 13, 0, 12, 3)
-      expect(stream.unpack('@14C12')).to eql [5, 10, 25, 45, 45, 55, 80, 125, 105, 150, 114, 165]
+      expect(stream.unpack("@14C12")).to eql [5, 10, 25, 45, 45, 55, 80, 125, 105, 150, 114, 165]
     end
 
     it "should decode a line with paeth filtering correctly" do
-      previous = [ChunkyPNG::FILTER_PAETH, 10, 20, 30, 40, 50, 60, 70, 80, 80, 100, 110, 120]
-      current  = [ChunkyPNG::FILTER_PAETH,  0,  0, 10, 20, 10,  0,  0, 40, 10,  20, 190,   0]
-      stream   = (previous + current).pack('C*')
+      previous = [ChunkyPNG::FILTER_PAETH, 10, 20, 30, 40, 50, 60, 70, 80, 80, 100, 110, 120] # rubocop:disable Layout/ExtraSpacing
+      current  = [ChunkyPNG::FILTER_PAETH,  0,  0, 10, 20, 10,  0,  0, 40, 10,  20, 190,   0] # rubocop:disable Layout/ExtraSpacing
+      stream   = (previous + current).pack("C*")
       decode_png_str_scanline(stream, 13, 0, 12, 3)
-      expect(stream.unpack('@14C12')).to eql [10, 20, 40, 60, 60, 60, 70, 120, 90, 120, 54, 120]
+      expect(stream.unpack("@14C12")).to eql [10, 20, 40, 60, 60, 60, 70, 120, 90, 120, 54, 120]
     end
   end
 
-  describe '#decode_png_extract_4bit_value' do
+  describe "#decode_png_extract_4bit_value" do
     it "should extract the high bits successfully" do
-      expect(decode_png_extract_4bit_value('10010110'.to_i(2), 0)).to eql '1001'.to_i(2)
+      expect(decode_png_extract_4bit_value("10010110".to_i(2), 0)).to eql "1001".to_i(2)
     end
 
     it "should extract the low bits successfully" do
-      expect(decode_png_extract_4bit_value('10010110'.to_i(2), 17)).to eql '0110'.to_i(2)
+      expect(decode_png_extract_4bit_value("10010110".to_i(2), 17)).to eql "0110".to_i(2)
     end
   end
 
-  describe '#decode_png_extract_2bit_value' do
+  describe "#decode_png_extract_2bit_value" do
     it "should extract the first 2 bits successfully" do
-      expect(decode_png_extract_2bit_value('10010110'.to_i(2), 0)).to eql '10'.to_i(2)
+      expect(decode_png_extract_2bit_value("10010110".to_i(2), 0)).to eql "10".to_i(2)
     end
 
     it "should extract the second 2 bits successfully" do
-      expect(decode_png_extract_2bit_value('10010110'.to_i(2), 5)).to eql '01'.to_i(2)
+      expect(decode_png_extract_2bit_value("10010110".to_i(2), 5)).to eql "01".to_i(2)
     end
 
     it "should extract the third 2 bits successfully" do
-      expect(decode_png_extract_2bit_value('10010110'.to_i(2), 2)).to eql '01'.to_i(2)
+      expect(decode_png_extract_2bit_value("10010110".to_i(2), 2)).to eql "01".to_i(2)
     end
 
     it "should extract the low two bits successfully" do
-      expect(decode_png_extract_2bit_value('10010110'.to_i(2), 7)).to eql '10'.to_i(2)
+      expect(decode_png_extract_2bit_value("10010110".to_i(2), 7)).to eql "10".to_i(2)
     end
   end
 
-  describe '#decode_png_extract_1bit_value' do
+  describe "#decode_png_extract_1bit_value" do
     it "should extract all separate bits correctly" do
-      expect(decode_png_extract_1bit_value('10010110'.to_i(2), 0)).to eql 1
-      expect(decode_png_extract_1bit_value('10010110'.to_i(2), 1)).to eql 0
-      expect(decode_png_extract_1bit_value('10010110'.to_i(2), 2)).to eql 0
-      expect(decode_png_extract_1bit_value('10010110'.to_i(2), 3)).to eql 1
-      expect(decode_png_extract_1bit_value('10010110'.to_i(2), 4)).to eql 0
-      expect(decode_png_extract_1bit_value('10010110'.to_i(2), 5)).to eql 1
-      expect(decode_png_extract_1bit_value('10010110'.to_i(2), 6)).to eql 1
-      expect(decode_png_extract_1bit_value('10010110'.to_i(2), 7)).to eql 0
+      expect(decode_png_extract_1bit_value("10010110".to_i(2), 0)).to eql 1
+      expect(decode_png_extract_1bit_value("10010110".to_i(2), 1)).to eql 0
+      expect(decode_png_extract_1bit_value("10010110".to_i(2), 2)).to eql 0
+      expect(decode_png_extract_1bit_value("10010110".to_i(2), 3)).to eql 1
+      expect(decode_png_extract_1bit_value("10010110".to_i(2), 4)).to eql 0
+      expect(decode_png_extract_1bit_value("10010110".to_i(2), 5)).to eql 1
+      expect(decode_png_extract_1bit_value("10010110".to_i(2), 6)).to eql 1
+      expect(decode_png_extract_1bit_value("10010110".to_i(2), 7)).to eql 0
     end
   end
 end