chunky_png 1.3.8 → 1.4.0

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

data/spec/chunky_png/canvas/stream_importing_spec.rb

@@ -1,30 +1,29 @@
-require 'spec_helper'
+require "spec_helper"
 
 describe ChunkyPNG::Canvas do
-
-  describe '.from_rgb_stream' do
+  describe ".from_rgb_stream" do
     it "should load an image correctly from a datastream" do
-      File.open(resource_file('pixelstream.rgb')) do |stream|
+      File.open(resource_file("pixelstream.rgb")) do |stream|
         matrix = ChunkyPNG::Canvas.from_rgb_stream(240, 180, stream)
-        expect(matrix).to eql reference_canvas('pixelstream_reference')
+        expect(matrix).to eql reference_canvas("pixelstream_reference")
       end
     end
   end
 
-  describe '.from_bgr_stream' do
+  describe ".from_bgr_stream" do
     it "should load an image correctly from a datastream" do
-      File.open(resource_file('pixelstream.bgr')) do |stream|
+      File.open(resource_file("pixelstream.bgr")) do |stream|
         matrix = ChunkyPNG::Canvas.from_bgr_stream(240, 180, stream)
-        expect(matrix).to eql reference_canvas('pixelstream_reference')
+        expect(matrix).to eql reference_canvas("pixelstream_reference")
       end
     end
   end
 
-  describe '.from_rgba_stream' do
+  describe ".from_rgba_stream" do
     it "should load an image correctly from a datastream" do
-      File.open(resource_file('pixelstream.rgba')) do |stream|
+      File.open(resource_file("pixelstream.rgba")) do |stream|
         matrix = ChunkyPNG::Canvas.from_rgba_stream(240, 180, stream)
-        expect(matrix).to eql reference_canvas('pixelstream_reference')
+        expect(matrix).to eql reference_canvas("pixelstream_reference")
       end
     end
   end

data/spec/chunky_png/canvas_spec.rb

@@ -1,17 +1,16 @@
-require 'spec_helper'
+require "spec_helper"
 
 describe ChunkyPNG::Canvas do
-
   subject { ChunkyPNG::Canvas.new(1, 1, ChunkyPNG::Color::WHITE) }
 
   it { should respond_to(:width) }
   it { should respond_to(:height) }
   it { should respond_to(:pixels) }
 
-  describe '#initialize' do
+  describe "#initialize" do
     it "should accept a single color value as background color" do
-      canvas = ChunkyPNG::Canvas.new(2, 2, 'red @ 0.8')
-      expect(canvas[1, 0]).to eql ChunkyPNG::Color.parse('red @ 0.8')
+      canvas = ChunkyPNG::Canvas.new(2, 2, "red @ 0.8")
+      expect(canvas[1, 0]).to eql ChunkyPNG::Color.parse("red @ 0.8")
     end
 
     it "should raise an error if the color value is not understood" do
@@ -19,7 +18,7 @@ describe ChunkyPNG::Canvas do
     end
 
     it "should accept an array as initial pixel values" do
-      canvas = ChunkyPNG::Canvas.new(2, 2, [1,2,3,4])
+      canvas = ChunkyPNG::Canvas.new(2, 2, [1, 2, 3, 4])
       expect(canvas[0, 0]).to eql 1
       expect(canvas[1, 0]).to eql 2
       expect(canvas[0, 1]).to eql 3
@@ -27,32 +26,32 @@ describe ChunkyPNG::Canvas do
     end
 
     it "should raise an ArgumentError if the initial array does not have the correct number of elements" do
-      expect { ChunkyPNG::Canvas.new(2, 2, [1,2,3]) }.to raise_error(ArgumentError)
-      expect { ChunkyPNG::Canvas.new(2, 2, [1,2,3,4,5]) }.to raise_error(ArgumentError)
+      expect { ChunkyPNG::Canvas.new(2, 2, [1, 2, 3]) }.to raise_error(ArgumentError)
+      expect { ChunkyPNG::Canvas.new(2, 2, [1, 2, 3, 4, 5]) }.to raise_error(ArgumentError)
     end
 
     it "should use a transparent background by default" do
       canvas = ChunkyPNG::Canvas.new(1, 1)
-      expect(canvas[0,0]).to eql ChunkyPNG::Color::TRANSPARENT
+      expect(canvas[0, 0]).to eql ChunkyPNG::Color::TRANSPARENT
     end
   end
 
-  describe '#dimension' do
+  describe "#dimension" do
     it "should return the dimensions as a Dimension instance" do
-      expect(subject.dimension).to eql ChunkyPNG::Dimension('1x1')
+      expect(subject.dimension).to eql ChunkyPNG::Dimension("1x1")
     end
   end
 
-  describe '#area' do
+  describe "#area" do
     it "should return the dimensions as two-item array" do
-      expect(subject.area).to eql ChunkyPNG::Dimension('1x1').area
+      expect(subject.area).to eql ChunkyPNG::Dimension("1x1").area
     end
   end
 
-  describe '#include?' do
+  describe "#include?" do
     it "should return true if the coordinates are within bounds, false otherwise" do
+      # rubocop:disable Layout/SpaceInsideParens
       expect(subject.include_xy?( 0,  0)).to eql true
-
       expect(subject.include_xy?(-1,  0)).to eql false
       expect(subject.include_xy?( 1,  0)).to eql false
       expect(subject.include_xy?( 0, -1)).to eql false
@@ -61,37 +60,38 @@ describe ChunkyPNG::Canvas do
       expect(subject.include_xy?(-1,  1)).to eql false
       expect(subject.include_xy?( 1, -1)).to eql false
       expect(subject.include_xy?( 1,  1)).to eql false
+      # rubocop:enable Layout/SpaceInsideParens
     end
 
     it "should accept strings, arrays, hashes and points as well" do
-      expect(subject).to     include('0, 0')
-      subject.should_not include('0, 1')
-      expect(subject).to     include([0, 0])
-      subject.should_not include([0, 1])
-      expect(subject).to     include(:y => 0, :x => 0)
-      subject.should_not include(:y => 1, :x => 0)
-      expect(subject).to     include(ChunkyPNG::Point.new(0, 0))
-      subject.should_not include(ChunkyPNG::Point.new(0, 1))
+      expect(subject).to include("0, 0")
+      expect(subject).to_not include("0, 1")
+      expect(subject).to include([0, 0])
+      expect(subject).to_not include([0, 1])
+      expect(subject).to include(y: 0, x: 0)
+      expect(subject).to_not include(y: 1, x: 0)
+      expect(subject).to include(ChunkyPNG::Point.new(0, 0))
+      expect(subject).to_not include(ChunkyPNG::Point.new(0, 1))
     end
   end
 
-  describe '#include_x?' do
+  describe "#include_x?" do
     it "should return true if the x-coordinate is within bounds, false otherwise" do
-      expect(subject.include_x?( 0)).to eql true
+      expect(subject.include_x?(0)).to eql true
       expect(subject.include_x?(-1)).to eql false
-      expect(subject.include_x?( 1)).to eql false
+      expect(subject.include_x?(1)).to eql false
     end
   end
 
-  describe '#include_y?' do
+  describe "#include_y?" do
     it "should return true if the y-coordinate is within bounds, false otherwise" do
-      expect(subject.include_y?( 0)).to eql true
+      expect(subject.include_y?(0)).to eql true
       expect(subject.include_y?(-1)).to eql false
-      expect(subject.include_y?( 1)).to eql false
+      expect(subject.include_y?(1)).to eql false
     end
   end
 
-  describe '#assert_xy!' do
+  describe "#assert_xy!" do
     it "should not raise an exception if the coordinates are within bounds" do
       expect(subject).to receive(:include_xy?).with(0, 0).and_return(true)
       expect { subject.send(:assert_xy!, 0, 0) }.to_not raise_error
@@ -103,7 +103,7 @@ describe ChunkyPNG::Canvas do
     end
   end
 
-  describe '#assert_x!' do
+  describe "#assert_x!" do
     it "should not raise an exception if the x-coordinate is within bounds" do
       expect(subject).to receive(:include_x?).with(0).and_return(true)
       expect { subject.send(:assert_x!, 0) }.to_not raise_error
@@ -115,7 +115,7 @@ describe ChunkyPNG::Canvas do
     end
   end
 
-  describe '#[]' do
+  describe "#[]" do
     it "should return the pixel value if the coordinates are within bounds" do
       expect(subject[0, 0]).to eql ChunkyPNG::Color::WHITE
     end
@@ -126,7 +126,7 @@ describe ChunkyPNG::Canvas do
     end
   end
 
-  describe '#get_pixel' do
+  describe "#get_pixel" do
     it "should return the pixel value if the coordinates are within bounds" do
       expect(subject.get_pixel(0, 0)).to eql ChunkyPNG::Color::WHITE
     end
@@ -138,10 +138,11 @@ describe ChunkyPNG::Canvas do
     end
   end
 
-  describe '#[]=' do
+  describe "#[]=" do
     it "should change the pixel's color value" do
-      expect { subject[0, 0] = ChunkyPNG::Color::BLACK }.to change { subject[0, 0] }.
-        from(ChunkyPNG::Color::WHITE).to(ChunkyPNG::Color::BLACK)
+      expect { subject[0, 0] = ChunkyPNG::Color::BLACK }.to change { subject[0, 0] }
+        .from(ChunkyPNG::Color::WHITE)
+        .to(ChunkyPNG::Color::BLACK)
     end
 
     it "should assert the bounds of the image" do
@@ -150,10 +151,11 @@ describe ChunkyPNG::Canvas do
     end
   end
 
-  describe 'set_pixel' do
+  describe "set_pixel" do
     it "should change the pixel's color value" do
-      expect { subject.set_pixel(0, 0, ChunkyPNG::Color::BLACK) }.to change { subject[0, 0] }.
-          from(ChunkyPNG::Color::WHITE).to(ChunkyPNG::Color::BLACK)
+      expect { subject.set_pixel(0, 0, ChunkyPNG::Color::BLACK) }.to change { subject[0, 0] }
+        .from(ChunkyPNG::Color::WHITE)
+        .to(ChunkyPNG::Color::BLACK)
     end
 
     it "should not assert or check the bounds of the image" do
@@ -163,10 +165,11 @@ describe ChunkyPNG::Canvas do
     end
   end
 
-  describe '#set_pixel_if_within_bounds' do
+  describe "#set_pixel_if_within_bounds" do
     it "should change the pixel's color value" do
-      expect { subject.set_pixel_if_within_bounds(0, 0, ChunkyPNG::Color::BLACK) }.to change { subject[0, 0] }.
-          from(ChunkyPNG::Color::WHITE).to(ChunkyPNG::Color::BLACK)
+      expect { subject.set_pixel_if_within_bounds(0, 0, ChunkyPNG::Color::BLACK) }.to change { subject[0, 0] }
+        .from(ChunkyPNG::Color::WHITE)
+        .to(ChunkyPNG::Color::BLACK)
     end
 
     it "should not assert, but only check the coordinates" do
@@ -181,8 +184,8 @@ describe ChunkyPNG::Canvas do
     end
   end
 
-  describe '#row' do
-    before { @canvas = reference_canvas('operations') }
+  describe "#row" do
+    before { @canvas = reference_canvas("operations") }
 
     it "should give an out of bounds exception when y-coordinate is out of bounds" do
       expect { @canvas.row(-1) }.to raise_error(ChunkyPNG::OutOfBounds)
@@ -196,8 +199,8 @@ describe ChunkyPNG::Canvas do
     end
   end
 
-  describe '#column' do
-    before { @canvas = reference_canvas('operations') }
+  describe "#column" do
+    before { @canvas = reference_canvas("operations") }
 
     it "should give an out of bounds exception when x-coordinate is out of bounds" do
       expect { @canvas.column(-1) }.to raise_error(ChunkyPNG::OutOfBounds)
@@ -211,19 +214,27 @@ describe ChunkyPNG::Canvas do
     end
   end
 
-  describe '#replace_canvas' do
+  describe "#replace_canvas" do
     it "should change the dimension of the canvas" do
-      expect { subject.send(:replace_canvas!, 2, 2, [1,2,3,4]) }.to change { subject.dimension }.
-          from(ChunkyPNG::Dimension('1x1')).to(ChunkyPNG::Dimension('2x2'))
+      expect { subject.send(:replace_canvas!, 2, 2, [1, 2, 3, 4]) }.to change { subject.dimension }
+        .from(ChunkyPNG::Dimension("1x1"))
+        .to(ChunkyPNG::Dimension("2x2"))
     end
 
     it "should change the pixel array" do
-      expect { subject.send(:replace_canvas!, 2, 2, [1,2,3,4]) }.to change { subject.pixels }.
-          from([ChunkyPNG::Color('white')]).to([1,2,3,4])
+      expect { subject.send(:replace_canvas!, 2, 2, [1, 2, 3, 4]) }.to change { subject.pixels }
+        .from([ChunkyPNG::Color("white")])
+        .to([1, 2, 3, 4])
     end
 
     it "should return itself" do
-      expect(subject.send(:replace_canvas!, 2, 2, [1,2,3,4])).to equal(subject)
+      expect(subject.send(:replace_canvas!, 2, 2, [1, 2, 3, 4])).to equal(subject)
+    end
+  end
+
+  describe "#inspect" do
+    it "should give a string description of the canvas" do
+      expect(subject.inspect).to eql "<ChunkyPNG::Canvas 1x1 [\n\t[#ffffffff]\n]>"
     end
   end
 end