chunky_png 1.3.11 → 1.3.12

data/spec/chunky_png/canvas/png_encoding_spec.rb

@@ -1,14 +1,14 @@
-require 'spec_helper'
+require "spec_helper"
 
 describe ChunkyPNG::Canvas::PNGEncoding do
   include ChunkyPNG::Canvas::PNGEncoding
 
-  context 'determining encoding options' do
+  context "determining encoding options" do
     [:indexed, :grayscale, :grayscale_alpha, :truecolor, :truecolor_alpha].each do |color_mode_name|
       it "should encode an image with color mode #{color_mode_name} correctly" do
         canvas = ChunkyPNG::Canvas.new(10, 10, ChunkyPNG::Color.rgb(100, 100, 100))
         color_mode = ChunkyPNG.const_get("COLOR_#{color_mode_name.to_s.upcase}")
-        blob = canvas.to_blob(:color_mode => color_mode)
+        blob = canvas.to_blob(color_mode: color_mode)
 
         ds = ChunkyPNG::Datastream.from_blob(blob)
         expect(ds.header_chunk.color).to eql color_mode
@@ -17,7 +17,7 @@ describe ChunkyPNG::Canvas::PNGEncoding do
     end
 
     it "should encode an image with 2 colors using 1-bit indexed color mode" do
-      @canvas = ChunkyPNG::Canvas.from_file(png_suite_file('basic', 'basn3p01.png'))
+      @canvas = ChunkyPNG::Canvas.from_file(png_suite_file("basic", "basn3p01.png"))
       ds = ChunkyPNG::Datastream.from_blob(@canvas.to_blob)
       expect(ds.header_chunk.color).to eql ChunkyPNG::COLOR_INDEXED
       expect(ds.header_chunk.depth).to eql 1
@@ -25,7 +25,7 @@ describe ChunkyPNG::Canvas::PNGEncoding do
     end
 
     it "should encode an image with 4 colors using 2-bit indexed color mode" do
-      @canvas = ChunkyPNG::Canvas.from_file(png_suite_file('basic', 'basn3p02.png'))
+      @canvas = ChunkyPNG::Canvas.from_file(png_suite_file("basic", "basn3p02.png"))
       ds = ChunkyPNG::Datastream.from_blob(@canvas.to_blob)
       expect(ds.header_chunk.color).to eql ChunkyPNG::COLOR_INDEXED
       expect(ds.header_chunk.depth).to eql 2
@@ -33,7 +33,7 @@ describe ChunkyPNG::Canvas::PNGEncoding do
     end
 
     it "should encode an image with 16 colors using 4-bit indexed color mode" do
-      @canvas = ChunkyPNG::Canvas.from_file(png_suite_file('basic', 'basn3p04.png'))
+      @canvas = ChunkyPNG::Canvas.from_file(png_suite_file("basic", "basn3p04.png"))
       ds = ChunkyPNG::Datastream.from_blob(@canvas.to_blob)
       expect(ds.header_chunk.color).to eql ChunkyPNG::COLOR_INDEXED
       expect(ds.header_chunk.depth).to eql 4
@@ -41,7 +41,7 @@ describe ChunkyPNG::Canvas::PNGEncoding do
     end
 
     it "should encode an image with 256 colors using 8-bit indexed color mode" do
-      @canvas = ChunkyPNG::Canvas.from_file(png_suite_file('basic', 'basn3p08.png'))
+      @canvas = ChunkyPNG::Canvas.from_file(png_suite_file("basic", "basn3p08.png"))
       ds = ChunkyPNG::Datastream.from_blob(@canvas.to_blob)
       expect(ds.header_chunk.color).to eql ChunkyPNG::COLOR_INDEXED
       expect(ds.header_chunk.depth).to eql 8
@@ -49,16 +49,16 @@ describe ChunkyPNG::Canvas::PNGEncoding do
     end
 
     it "should use a higher bit depth than necessary if requested" do
-      @canvas = ChunkyPNG::Canvas.from_file(png_suite_file('basic', 'basn3p01.png'))
-      ds = ChunkyPNG::Datastream.from_blob(@canvas.to_blob(:bit_depth => 4))
+      @canvas = ChunkyPNG::Canvas.from_file(png_suite_file("basic", "basn3p01.png"))
+      ds = ChunkyPNG::Datastream.from_blob(@canvas.to_blob(bit_depth: 4))
       expect(ds.header_chunk.color).to eql ChunkyPNG::COLOR_INDEXED
       expect(ds.header_chunk.depth).to eql 4
       expect(@canvas).to eql ChunkyPNG::Canvas.from_datastream(ds)
     end
 
     it "should encode an image with interlacing correctly" do
-      input_canvas = ChunkyPNG::Canvas.from_file(resource_file('operations.png'))
-      blob = input_canvas.to_blob(:interlace => true)
+      input_canvas = ChunkyPNG::Canvas.from_file(resource_file("operations.png"))
+      blob = input_canvas.to_blob(interlace: true)
 
       ds = ChunkyPNG::Datastream.from_blob(blob)
       expect(ds.header_chunk.interlace).to eql ChunkyPNG::INTERLACING_ADAM7
@@ -66,55 +66,57 @@ describe ChunkyPNG::Canvas::PNGEncoding do
     end
 
     it "should save an image using the normal routine correctly" do
-      canvas = reference_canvas('operations')
-      expect(Zlib::Deflate).to receive(:deflate).with(anything, Zlib::DEFAULT_COMPRESSION).and_return('')
+      canvas = reference_canvas("operations")
+      expect(Zlib::Deflate).to receive(:deflate).with(anything, Zlib::DEFAULT_COMPRESSION).and_return("")
       canvas.to_blob
     end
 
     it "should save an image using the :fast_rgba routine correctly" do
-      canvas = reference_canvas('operations')
+      canvas = reference_canvas("operations")
       expect(canvas).to_not receive(:encode_png_str_scanline_none)
       expect(canvas).to_not receive(:encode_png_str_scanline_sub)
       expect(canvas).to_not receive(:encode_png_str_scanline_up)
       expect(canvas).to_not receive(:encode_png_str_scanline_average)
       expect(canvas).to_not receive(:encode_png_str_scanline_paeth)
-      expect(Zlib::Deflate).to receive(:deflate).with(anything, Zlib::BEST_SPEED).and_return('')
+      expect(Zlib::Deflate).to receive(:deflate).with(anything, Zlib::BEST_SPEED).and_return("")
       canvas.to_blob(:fast_rgba)
     end
 
     it "should save an image using the :good_compression routine correctly" do
-      canvas = reference_canvas('operations')
+      canvas = reference_canvas("operations")
       expect(canvas).to_not receive(:encode_png_str_scanline_none)
       expect(canvas).to_not receive(:encode_png_str_scanline_sub)
       expect(canvas).to_not receive(:encode_png_str_scanline_up)
       expect(canvas).to_not receive(:encode_png_str_scanline_average)
       expect(canvas).to_not receive(:encode_png_str_scanline_paeth)
-      expect(Zlib::Deflate).to receive(:deflate).with(anything, Zlib::BEST_COMPRESSION).and_return('')
+      expect(Zlib::Deflate).to receive(:deflate).with(anything, Zlib::BEST_COMPRESSION).and_return("")
       canvas.to_blob(:good_compression)
     end
 
     it "should save an image using the :best_compression routine correctly" do
-      canvas = reference_canvas('operations')
+      canvas = reference_canvas("operations")
       expect(canvas).to receive(:encode_png_str_scanline_paeth).exactly(canvas.height).times
-      expect(Zlib::Deflate).to receive(:deflate).with(anything, Zlib::BEST_COMPRESSION).and_return('')
+      expect(Zlib::Deflate).to receive(:deflate).with(anything, Zlib::BEST_COMPRESSION).and_return("")
       canvas.to_blob(:best_compression)
     end
 
     it "should save an image with black and white only if requested" do
-      ds = ChunkyPNG::Datastream.from_blob(reference_canvas('lines').to_blob(:black_and_white))
+      ds = ChunkyPNG::Datastream.from_blob(reference_canvas("lines").to_blob(:black_and_white))
       expect(ds.header_chunk.color).to eql ChunkyPNG::COLOR_GRAYSCALE
       expect(ds.header_chunk.depth).to eql 1
     end
   end
 
-  describe 'different color modes and bit depths' do
+  describe "different color modes and bit depths" do
     before do
       @canvas = ChunkyPNG::Canvas.new(2, 2)
 
+      # rubocop:disable Layout/ExtraSpacing, Layout/SpaceInsideParens
       @canvas[0, 0] = ChunkyPNG::Color.rgba(  1,   2,   3,   4)
       @canvas[1, 0] = ChunkyPNG::Color.rgba(252, 253, 254, 255)
       @canvas[0, 1] = ChunkyPNG::Color.rgba(255, 254, 253, 252)
       @canvas[1, 1] = ChunkyPNG::Color.rgba(  4,   3,   2,   1)
+      # rubocop:enable Layout/ExtraSpacing, Layout/SpaceInsideParens
 
       @canvas.encoding_palette = @canvas.palette
       @canvas.encoding_palette.to_plte_chunk
@@ -122,32 +124,32 @@ describe ChunkyPNG::Canvas::PNGEncoding do
 
     it "should encode using 8-bit RGBA mode correctly" do
       stream = @canvas.encode_png_pixelstream(ChunkyPNG::COLOR_TRUECOLOR_ALPHA, 8, ChunkyPNG::INTERLACING_NONE, ChunkyPNG::FILTER_NONE)
-      expect(stream).to eql ChunkyPNG.force_binary("\0\x01\x02\x03\x04\xFC\xFD\xFE\xFF\0\xFF\xFE\xFD\xFC\x04\x03\x02\x01")
+      expect(stream).to eql "\0\x01\x02\x03\x04\xFC\xFD\xFE\xFF\0\xFF\xFE\xFD\xFC\x04\x03\x02\x01".force_encoding(Encoding::BINARY)
     end
 
     it "should encode using 8 bit RGB mode correctly" do
       stream = @canvas.encode_png_pixelstream(ChunkyPNG::COLOR_TRUECOLOR, 8, ChunkyPNG::INTERLACING_NONE, ChunkyPNG::FILTER_NONE)
-      expect(stream).to eql ChunkyPNG.force_binary("\0\x01\x02\x03\xFC\xFD\xFE\0\xFF\xFE\xFD\x04\x03\x02")
+      expect(stream).to eql "\0\x01\x02\x03\xFC\xFD\xFE\0\xFF\xFE\xFD\x04\x03\x02".force_encoding(Encoding::BINARY)
     end
 
     it "should encode using 1-bit grayscale mode correctly" do
       stream = @canvas.encode_png_pixelstream(ChunkyPNG::COLOR_GRAYSCALE, 1, ChunkyPNG::INTERLACING_NONE, ChunkyPNG::FILTER_NONE)
-      expect(stream).to eql ChunkyPNG.force_binary("\0\x40\0\x80") # Using the B byte of the pixel == 3, assuming R == G == B for grayscale images
+      expect(stream).to eql "\0\x40\0\x80".force_encoding(Encoding::BINARY) # Using the B byte of the pixel == 3, assuming R == G == B for grayscale images
     end
 
     it "should encode using 2-bit grayscale mode correctly" do
       stream = @canvas.encode_png_pixelstream(ChunkyPNG::COLOR_GRAYSCALE, 2, ChunkyPNG::INTERLACING_NONE, ChunkyPNG::FILTER_NONE)
-      expect(stream).to eql ChunkyPNG.force_binary("\0\x30\0\xC0") # Using the B byte of the pixel == 3, assuming R == G == B for grayscale images
+      expect(stream).to eql "\0\x30\0\xC0".force_encoding(Encoding::BINARY) # Using the B byte of the pixel == 3, assuming R == G == B for grayscale images
     end
 
     it "should encode using 4-bit grayscale mode correctly" do
       stream = @canvas.encode_png_pixelstream(ChunkyPNG::COLOR_GRAYSCALE, 4, ChunkyPNG::INTERLACING_NONE, ChunkyPNG::FILTER_NONE)
-      expect(stream).to eql ChunkyPNG.force_binary("\0\x0F\0\xF0") # Using the B byte of the pixel == 3, assuming R == G == B for grayscale images
+      expect(stream).to eql "\0\x0F\0\xF0".force_encoding(Encoding::BINARY) # Using the B byte of the pixel == 3, assuming R == G == B for grayscale images
     end
 
     it "should encode using 8-bit grayscale mode correctly" do
       stream = @canvas.encode_png_pixelstream(ChunkyPNG::COLOR_GRAYSCALE, 8, ChunkyPNG::INTERLACING_NONE, ChunkyPNG::FILTER_NONE)
-      expect(stream).to eql ChunkyPNG.force_binary("\0\x03\xFE\0\xFD\x02") # Using the B byte of the pixel == 3, assuming R == G == B for grayscale images
+      expect(stream).to eql "\0\x03\xFE\0\xFD\x02".force_encoding(Encoding::BINARY) # Using the B byte of the pixel == 3, assuming R == G == B for grayscale images
     end
 
     it "should not encode using 1-bit indexed mode because the image has too many colors" do
@@ -158,78 +160,85 @@ describe ChunkyPNG::Canvas::PNGEncoding do
 
     it "should encode using 2-bit indexed mode correctly" do
       stream = @canvas.encode_png_pixelstream(ChunkyPNG::COLOR_INDEXED, 2, ChunkyPNG::INTERLACING_NONE, ChunkyPNG::FILTER_NONE)
-      expect(stream).to eql ChunkyPNG.force_binary("\0\x20\0\xD0")
+      expect(stream).to eql "\0\x20\0\xD0".force_encoding(Encoding::BINARY)
     end
 
     it "should encode using 4-bit indexed mode correctly" do
       stream = @canvas.encode_png_pixelstream(ChunkyPNG::COLOR_INDEXED, 4, ChunkyPNG::INTERLACING_NONE, ChunkyPNG::FILTER_NONE)
-      expect(stream).to eql ChunkyPNG.force_binary("\0\x02\0\x31")
+      expect(stream).to eql "\0\x02\0\x31".force_encoding(Encoding::BINARY)
     end
 
     it "should encode using 8-bit indexed mode correctly" do
       stream = @canvas.encode_png_pixelstream(ChunkyPNG::COLOR_INDEXED, 8, ChunkyPNG::INTERLACING_NONE, ChunkyPNG::FILTER_NONE)
-      expect(stream).to eql ChunkyPNG.force_binary("\0\x00\x02\0\x03\x01")
+      expect(stream).to eql "\0\x00\x02\0\x03\x01".force_encoding(Encoding::BINARY)
     end
   end
 
-  describe 'different filter methods' do
-
+  describe "different filter methods" do
     it "should encode a scanline without filtering correctly" do
-      stream = [ChunkyPNG::FILTER_NONE, 0, 0, 0, 1, 1, 1, 2, 2, 2].pack('C*')
+      stream = [ChunkyPNG::FILTER_NONE, 0, 0, 0, 1, 1, 1, 2, 2, 2].pack("C*")
       encode_png_str_scanline_none(stream, 0, nil, 9, 3)
-      expect(stream.unpack('C*')).to eql [ChunkyPNG::FILTER_NONE, 0, 0, 0, 1, 1, 1, 2, 2, 2]
+      expect(stream.unpack("C*")).to eql [ChunkyPNG::FILTER_NONE, 0, 0, 0, 1, 1, 1, 2, 2, 2]
     end
 
     it "should encode a scanline with sub filtering correctly" do
-      stream = [ChunkyPNG::FILTER_NONE, 255, 255, 255, 255, 255, 255, 255, 255, 255,
-                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,
+        ChunkyPNG::FILTER_NONE, 255, 255, 255, 255, 255, 255, 255, 255, 255,
+      ].pack("C*")
 
       # Check line with previous line
       encode_png_str_scanline_sub(stream, 10, 0, 9, 3)
-      expect(stream.unpack('@10C10')).to eql [ChunkyPNG::FILTER_SUB, 255, 255, 255, 0, 0, 0, 0, 0, 0]
+      expect(stream.unpack("@10C10")).to eql [ChunkyPNG::FILTER_SUB, 255, 255, 255, 0, 0, 0, 0, 0, 0]
 
       # Check line without previous line
       encode_png_str_scanline_sub(stream, 0, nil, 9, 3)
-      expect(stream.unpack('@0C10')).to eql [ChunkyPNG::FILTER_SUB, 255, 255, 255, 0, 0, 0, 0, 0, 0]
+      expect(stream.unpack("@0C10")).to eql [ChunkyPNG::FILTER_SUB, 255, 255, 255, 0, 0, 0, 0, 0, 0]
     end
 
     it "should encode a scanline with up filtering correctly" do
-      stream = [ChunkyPNG::FILTER_NONE, 255, 255, 255, 255, 255, 255, 255, 255, 255,
-                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,
+        ChunkyPNG::FILTER_NONE, 255, 255, 255, 255, 255, 255, 255, 255, 255,
+      ].pack("C*")
 
       # Check line with previous line
       encode_png_str_scanline_up(stream, 10, 0, 9, 3)
-      expect(stream.unpack('@10C10')).to eql [ChunkyPNG::FILTER_UP, 0, 0, 0, 0, 0, 0, 0, 0, 0]
+      expect(stream.unpack("@10C10")).to eql [ChunkyPNG::FILTER_UP, 0, 0, 0, 0, 0, 0, 0, 0, 0]
 
       # Check line without previous line
       encode_png_str_scanline_up(stream, 0, nil, 9, 3)
-      expect(stream.unpack('@0C10')).to eql [ChunkyPNG::FILTER_UP, 255, 255, 255, 255, 255, 255, 255, 255, 255]
+      expect(stream.unpack("@0C10")).to eql [ChunkyPNG::FILTER_UP, 255, 255, 255, 255, 255, 255, 255, 255, 255]
     end
 
     it "should encode a scanline with average filtering correctly" do
-      stream = [ChunkyPNG::FILTER_NONE, 10, 20, 30, 40, 50, 60, 70, 80,   80, 100, 110, 120,
-                ChunkyPNG::FILTER_NONE,  5, 10, 25, 45, 45, 55, 80, 125, 105, 150, 114, 165].pack('C*')
+      stream = [
+        ChunkyPNG::FILTER_NONE, 10, 20, 30, 40, 50, 60, 70, 80,   80, 100, 110, 120, # rubocop:disable Layout/ExtraSpacing
+        ChunkyPNG::FILTER_NONE,  5, 10, 25, 45, 45, 55, 80, 125, 105, 150, 114, 165, # rubocop:disable Layout/ExtraSpacing
+      ].pack("C*")
 
       # Check line with previous line
       encode_png_str_scanline_average(stream, 13, 0, 12, 3)
-      expect(stream.unpack('@13C13')).to eql [ChunkyPNG::FILTER_AVERAGE, 0, 0, 10, 23, 15, 13, 23, 63, 38, 60, 253, 53]
+      expect(stream.unpack("@13C13")).to eql [ChunkyPNG::FILTER_AVERAGE, 0, 0, 10, 23, 15, 13, 23, 63, 38, 60, 253, 53]
 
       # Check line without previous line
       encode_png_str_scanline_average(stream, 0, nil, 12, 3)
-      expect(stream.unpack('@0C13')).to eql [ChunkyPNG::FILTER_AVERAGE, 10, 20, 30, 35, 40, 45, 50, 55, 50, 65, 70, 80]
+      expect(stream.unpack("@0C13")).to eql [ChunkyPNG::FILTER_AVERAGE, 10, 20, 30, 35, 40, 45, 50, 55, 50, 65, 70, 80]
     end
 
     it "should encode a scanline with paeth filtering correctly" do
-      stream = [ChunkyPNG::FILTER_NONE, 10, 20, 30, 40, 50, 60, 70,  80, 80, 100, 110, 120,
-                ChunkyPNG::FILTER_NONE, 10, 20, 40, 60, 60, 60, 70, 120, 90, 120,  54, 120].pack('C*')
+      stream = [
+        ChunkyPNG::FILTER_NONE, 10, 20, 30, 40, 50, 60, 70,  80, 80, 100, 110, 120, # rubocop:disable Layout/ExtraSpacing
+        ChunkyPNG::FILTER_NONE, 10, 20, 40, 60, 60, 60, 70, 120, 90, 120,  54, 120, # rubocop:disable Layout/ExtraSpacing
+      ].pack("C*")
 
       # Check line with previous line
       encode_png_str_scanline_paeth(stream, 13, 0, 12, 3)
-      expect(stream.unpack('@13C13')).to eql [ChunkyPNG::FILTER_PAETH, 0, 0, 10, 20, 10, 0, 0, 40, 10, 20, 190, 0]
+      expect(stream.unpack("@13C13")).to eql [ChunkyPNG::FILTER_PAETH, 0, 0, 10, 20, 10, 0, 0, 40, 10, 20, 190, 0]
 
       # Check line without previous line
       encode_png_str_scanline_paeth(stream, 0, nil, 12, 3)
-      expect(stream.unpack('@0C13')).to eql [ChunkyPNG::FILTER_PAETH, 10, 20, 30, 30, 30, 30, 30, 30, 20, 30, 30, 40]
+      expect(stream.unpack("@0C13")).to eql [ChunkyPNG::FILTER_PAETH, 10, 20, 30, 30, 30, 30, 30, 30, 20, 30, 30, 40]
     end
   end
 end

data/spec/chunky_png/canvas/resampling_spec.rb

@@ -1,11 +1,9 @@
-require 'spec_helper'
+require "spec_helper"
 
 describe ChunkyPNG::Canvas::Resampling do
+  subject { reference_canvas("clock") }
 
-  subject { reference_canvas('clock') }
-
-  describe '#resample_nearest_neighbor' do
-
+  describe "#resample_nearest_neighbor" do
     it "should downscale from 2x2 to 1x1 correctly" do
       canvas = ChunkyPNG::Canvas.new(2, 2, [1, 2, 3, 4])
       expect(canvas.resample_nearest_neighbor(1, 1)).to eql ChunkyPNG::Canvas.new(1, 1, [4])
@@ -17,15 +15,15 @@ describe ChunkyPNG::Canvas::Resampling do
     end
 
     it "should upscale both axis of the image" do
-      expect(subject.resample_nearest_neighbor(45, 45)).to eql reference_canvas('clock_nn_xup_yup')
+      expect(subject.resample_nearest_neighbor(45, 45)).to eql reference_canvas("clock_nn_xup_yup")
     end
 
     it "should downscale both axis of the image" do
-      expect(subject.resample_nearest_neighbor(12, 12)).to eql reference_canvas('clock_nn_xdown_ydown')
+      expect(subject.resample_nearest_neighbor(12, 12)).to eql reference_canvas("clock_nn_xdown_ydown")
     end
 
     it "should downscale the x-axis and upscale the y-axis of the image" do
-      expect(subject.resample_nearest_neighbor(20, 50)).to eql reference_canvas('clock_nn_xdown_yup')
+      expect(subject.resample_nearest_neighbor(20, 50)).to eql reference_canvas("clock_nn_xdown_yup")
     end
 
     it "should not return itself" do
@@ -37,20 +35,20 @@ describe ChunkyPNG::Canvas::Resampling do
     end
   end
 
-  describe '#resample_nearest_neighbor!' do
+  describe "#resample_nearest_neighbor!" do
     it "should upscale both axis of the image" do
       subject.resample_nearest_neighbor!(45, 45)
-      expect(subject).to eql reference_canvas('clock_nn_xup_yup')
+      expect(subject).to eql reference_canvas("clock_nn_xup_yup")
     end
 
     it "should downscale both axis of the image" do
       subject.resample_nearest_neighbor!(12, 12)
-      expect(subject).to eql reference_canvas('clock_nn_xdown_ydown')
+      expect(subject).to eql reference_canvas("clock_nn_xdown_ydown")
     end
 
     it "should downscale the x-axis and upscale the y-axis of the image" do
       subject.resample_nearest_neighbor!(20, 50)
-      expect(subject).to eql reference_canvas('clock_nn_xdown_yup')
+      expect(subject).to eql reference_canvas("clock_nn_xdown_yup")
     end
 
     it "should return itself" do
@@ -58,7 +56,7 @@ describe ChunkyPNG::Canvas::Resampling do
     end
 
     it "should change the original image's dimensions" do
-      expect { subject.resample_nearest_neighbor!(1, 1) }.to change { subject.dimension }.to(ChunkyPNG::Dimension('1x1'))
+      expect { subject.resample_nearest_neighbor!(1, 1) }.to change { subject.dimension }.to(ChunkyPNG::Dimension("1x1"))
     end
   end
 
@@ -74,15 +72,15 @@ describe ChunkyPNG::Canvas::Resampling do
     end
 
     it "should upscale both axis of the image" do
-      expect(subject.resample_bilinear(45, 45)).to eql reference_canvas('clock_bl_xup_yup')
+      expect(subject.resample_bilinear(45, 45)).to eql reference_canvas("clock_bl_xup_yup")
     end
 
     it "should downscale both axis of the image" do
-      expect(subject.resample_bilinear(12, 12)).to eql reference_canvas('clock_bl_xdown_ydown')
+      expect(subject.resample_bilinear(12, 12)).to eql reference_canvas("clock_bl_xdown_ydown")
     end
 
     it "should downscale the x-axis and upscale the y-axis of the image" do
-      expect(subject.resample_bilinear(20, 50)).to eql reference_canvas('clock_bl_xdown_yup')
+      expect(subject.resample_bilinear(20, 50)).to eql reference_canvas("clock_bl_xdown_yup")
     end
 
     it "should not return itself" do
@@ -94,20 +92,20 @@ describe ChunkyPNG::Canvas::Resampling do
     end
   end
 
-  describe '#resample_bilinear!' do
+  describe "#resample_bilinear!" do
     it "should upscale both axis of the image" do
       subject.resample_bilinear!(45, 45)
-      expect(subject).to eql reference_canvas('clock_bl_xup_yup')
+      expect(subject).to eql reference_canvas("clock_bl_xup_yup")
     end
 
     it "should downscale both axis of the image" do
       subject.resample_bilinear!(12, 12)
-      expect(subject).to eql reference_canvas('clock_bl_xdown_ydown')
+      expect(subject).to eql reference_canvas("clock_bl_xdown_ydown")
     end
 
     it "should downscale the x-axis and upscale the y-axis of the image" do
       subject.resample_bilinear!(20, 50)
-      expect(subject).to eql reference_canvas('clock_bl_xdown_yup')
+      expect(subject).to eql reference_canvas("clock_bl_xdown_yup")
     end
 
     it "should return itself" do
@@ -115,7 +113,7 @@ describe ChunkyPNG::Canvas::Resampling do
     end
 
     it "should change the original image's dimensions" do
-      expect { subject.resample_bilinear!(1, 1) }.to change { subject.dimension }.to(ChunkyPNG::Dimension('1x1'))
+      expect { subject.resample_bilinear!(1, 1) }.to change { subject.dimension }.to(ChunkyPNG::Dimension("1x1"))
     end
   end
 end

data/spec/chunky_png/canvas/stream_exporting_spec.rb

@@ -1,59 +1,79 @@
-require 'spec_helper'
+require "spec_helper"
 
 describe ChunkyPNG::Canvas do
-
-  describe '#to_rgba_stream' do
+  describe "#to_rgba_stream" do
     it "should export a sample canvas to an RGBA stream correctly" do
-      canvas = ChunkyPNG::Canvas.new(2, 2, [ChunkyPNG::Color.rgba(1,2,3,4), ChunkyPNG::Color.rgba(5,6,7,8),
-                                            ChunkyPNG::Color.rgba(4,3,2,1), ChunkyPNG::Color.rgba(8,7,6,5)])
+      canvas = ChunkyPNG::Canvas.new(2, 2, [
+        ChunkyPNG::Color.rgba(1, 2, 3, 4),
+        ChunkyPNG::Color.rgba(5, 6, 7, 8),
+        ChunkyPNG::Color.rgba(4, 3, 2, 1),
+        ChunkyPNG::Color.rgba(8, 7, 6, 5),
+      ])
 
-      expect(canvas.to_rgba_stream).to eql  [1,2,3,4,5,6,7,8,4,3,2,1,8,7,6,5].pack('C16')
+      expect(canvas.to_rgba_stream).to eql [1, 2, 3, 4, 5, 6, 7, 8, 4, 3, 2, 1, 8, 7, 6, 5].pack("C16")
     end
 
     it "should export an image to an RGBA datastream correctly" do
-      expect(reference_canvas('pixelstream_reference').to_rgba_stream).to eql resource_data('pixelstream.rgba')
+      expect(reference_canvas("pixelstream_reference").to_rgba_stream).to eql resource_data("pixelstream.rgba")
     end
   end
 
-  describe '#to_rgb_stream' do
+  describe "#to_rgb_stream" do
     it "should export a sample canvas to an RGBA stream correctly" do
-      canvas = ChunkyPNG::Canvas.new(2, 2, [ChunkyPNG::Color.rgba(1,2,3,4), ChunkyPNG::Color.rgba(5,6,7,8),
-                                            ChunkyPNG::Color.rgba(4,3,2,1), ChunkyPNG::Color.rgba(8,7,6,5)])
+      canvas = ChunkyPNG::Canvas.new(2, 2, [
+        ChunkyPNG::Color.rgba(1, 2, 3, 4),
+        ChunkyPNG::Color.rgba(5, 6, 7, 8),
+        ChunkyPNG::Color.rgba(4, 3, 2, 1),
+        ChunkyPNG::Color.rgba(8, 7, 6, 5),
+      ])
 
-      expect(canvas.to_rgb_stream).to eql [1,2,3,5,6,7,4,3,2,8,7,6].pack('C12')
+      expect(canvas.to_rgb_stream).to eql [1, 2, 3, 5, 6, 7, 4, 3, 2, 8, 7, 6].pack("C12")
     end
 
     it "should export an image to an RGB datastream correctly" do
-      expect(reference_canvas('pixelstream_reference').to_rgb_stream).to eql resource_data('pixelstream.rgb')
+      expect(reference_canvas("pixelstream_reference").to_rgb_stream).to eql resource_data("pixelstream.rgb")
     end
   end
 
-  describe '#to_grayscale_stream' do
-
+  describe "#to_grayscale_stream" do
     it "should export a grayscale image to a grayscale datastream correctly" do
-      canvas = ChunkyPNG::Canvas.new(2, 2, [ChunkyPNG::Color.grayscale(1), ChunkyPNG::Color.grayscale(2),
-                                            ChunkyPNG::Color.grayscale(3), ChunkyPNG::Color.grayscale(4)])
-      expect(canvas.to_grayscale_stream).to eql [1,2,3,4].pack('C4')
-    end
+      canvas = ChunkyPNG::Canvas.new(2, 2, [
+        ChunkyPNG::Color.grayscale(1),
+        ChunkyPNG::Color.grayscale(2),
+        ChunkyPNG::Color.grayscale(3),
+        ChunkyPNG::Color.grayscale(4),
+      ])
 
+      expect(canvas.to_grayscale_stream).to eql [1, 2, 3, 4].pack("C4")
+    end
 
     it "should export a color image to a grayscale datastream, using B values" do
-      canvas = ChunkyPNG::Canvas.new(2, 2, [ChunkyPNG::Color.rgba(1,2,3,4), ChunkyPNG::Color.rgba(5,6,7,8),
-                                            ChunkyPNG::Color.rgba(4,3,2,1), ChunkyPNG::Color.rgba(8,7,6,5)])
-      expect(canvas.to_grayscale_stream).to eql [3,7,2,6].pack('C4')
+      canvas = ChunkyPNG::Canvas.new(2, 2, [
+        ChunkyPNG::Color.rgba(1, 2, 3, 4),
+        ChunkyPNG::Color.rgba(5, 6, 7, 8),
+        ChunkyPNG::Color.rgba(4, 3, 2, 1),
+        ChunkyPNG::Color.rgba(8, 7, 6, 5),
+      ])
+
+      expect(canvas.to_grayscale_stream).to eql [3, 7, 2, 6].pack("C4")
     end
   end
 
-  describe '#to_alpha_channel_stream' do
+  describe "#to_alpha_channel_stream" do
     it "should export an opaque image to an alpha channel datastream correctly" do
-      grayscale_array = Array.new(reference_canvas('pixelstream_reference').pixels.length, 255)
-      expect(reference_canvas('pixelstream_reference').to_alpha_channel_stream).to eql grayscale_array.pack('C*')
+      grayscale_array = Array.new(reference_canvas("pixelstream_reference").pixels.length, 255)
+      expect(reference_canvas("pixelstream_reference").to_alpha_channel_stream).to eql grayscale_array.pack("C*")
     end
 
     it "should export a transparent image to an alpha channel datastream correctly" do
-      canvas = ChunkyPNG::Canvas.new(2, 2, [ChunkyPNG::Color.rgba(1,2,3,4), ChunkyPNG::Color.rgba(5,6,7,8),
-                                            ChunkyPNG::Color.rgba(4,3,2,1), ChunkyPNG::Color.rgba(8,7,6,5)])
-      expect(canvas.to_alpha_channel_stream).to eql [4,8,1,5].pack('C4')
+      canvas = ChunkyPNG::Canvas.new(2, 2, [
+        ChunkyPNG::Color.rgba(1, 2, 3, 4),
+        ChunkyPNG::Color.rgba(5, 6, 7, 8),
+        ChunkyPNG::Color.rgba(4, 3, 2, 1),
+        ChunkyPNG::Color.rgba(8, 7, 6, 5),
+      ])
+
+      expect(canvas.to_alpha_channel_stream).to eql [4, 8, 1, 5].pack("C4")
     end
   end
 end