chunky_png 1.3.2 → 1.3.3

data/spec/chunky_png/canvas/drawing_spec.rb

@@ -1,30 +1,30 @@
 require 'spec_helper'
 
 describe ChunkyPNG::Canvas::Drawing do
-  
+
   describe '#compose_pixel' do
     subject { ChunkyPNG::Canvas.new(1, 1, ChunkyPNG::Color.rgb(200, 150, 100)) }
-    
+
     it "should compose colors correctly" do
       subject.compose_pixel(0,0, ChunkyPNG::Color(100, 150, 200, 128))
-      subject[0, 0].should == ChunkyPNG::Color(150, 150, 150)
+      expect(subject[0, 0]).to eql ChunkyPNG::Color(150, 150, 150)
     end
-    
+
     it "should return the composed color" do
-      subject.compose_pixel(0, 0, ChunkyPNG::Color.rgba(100, 150, 200, 128)).should == ChunkyPNG::Color.rgb(150, 150, 150)
+      expect(subject.compose_pixel(0, 0, ChunkyPNG::Color.rgba(100, 150, 200, 128))).to eql ChunkyPNG::Color.rgb(150, 150, 150)
     end
-    
+
     it "should do nothing when the coordinates are out of bounds" do
-      subject.compose_pixel(1, -1, :black).should be_nil
-      lambda { subject.compose_pixel(1, -1, :black) }.should_not change { subject[0, 0] }
+      expect(subject.compose_pixel(1, -1, :black)).to be_nil
+      expect { subject.compose_pixel(1, -1, :black) }.to_not change { subject[0, 0] }
     end
   end
-  
+
   describe '#line' do
     it "should draw lines correctly with anti-aliasing" do
-      
+
       canvas = ChunkyPNG::Canvas.new(31, 31, ChunkyPNG::Color::WHITE)
-      
+
       canvas.line( 0,  0, 30, 30, ChunkyPNG::Color::BLACK)
       canvas.line( 0, 30, 30,  0, ChunkyPNG::Color::BLACK)
       canvas.line(15, 30, 15,  0, ChunkyPNG::Color.rgba(200,   0,   0, 128))
@@ -34,137 +34,137 @@ describe ChunkyPNG::Canvas::Drawing do
       canvas.line( 0, 30, 15,  0, ChunkyPNG::Color.rgba(  0,   0, 200, 128), false)
       canvas.line(15,  0, 30, 30, ChunkyPNG::Color.rgba(  0,   0, 200, 128))
 
-      canvas.should == reference_canvas('lines')
+      expect(canvas).to eql reference_canvas('lines')
     end
-    
+
     it "should draw partial lines if the coordinates are partially out of bounds" do
       canvas = ChunkyPNG::Canvas.new(1, 2, ChunkyPNG::Color::WHITE)
       canvas.line(-5, -5, 0, 0, '#000000')
-      canvas.pixels.should == [ChunkyPNG::Color::BLACK, ChunkyPNG::Color::WHITE]
+      expect(canvas.pixels).to eql [ChunkyPNG::Color::BLACK, ChunkyPNG::Color::WHITE]
     end
-    
+
     it "should return itself to allow chaining" do
       canvas = ChunkyPNG::Canvas.new(16, 16, ChunkyPNG::Color::WHITE)
-      canvas.line(1, 1, 10, 10, :black).should equal(canvas)
+      expect(canvas.line(1, 1, 10, 10, :black)).to equal(canvas)
     end
   end
-  
+
   describe '#rect' do
     subject { ChunkyPNG::Canvas.new(16, 16, '#ffffff') }
-    
+
     it "should draw a rectangle with the correct colors" do
       subject.rect(1, 1, 10, 10, ChunkyPNG::Color.rgba(0, 255, 0,  80), ChunkyPNG::Color.rgba(255, 0, 0, 100))
       subject.rect(5, 5, 14, 14, ChunkyPNG::Color.rgba(0, 0, 255, 160), ChunkyPNG::Color.rgba(255, 255, 0, 100))
-      subject.should == reference_canvas('rect')
+      expect(subject).to eql reference_canvas('rect')
     end
-    
+
     it "should return itself to allow chaining" do
-      subject.rect(1, 1, 10, 10).should equal(subject)
+      expect(subject.rect(1, 1, 10, 10)).to equal(subject)
     end
-    
+
     it "should draw partial rectangles if the coordinates are partially out of bounds" do
       subject.rect(0, 0, 20, 20, :black, :white)
-      subject[0, 0].should == ChunkyPNG::Color::BLACK
+      expect(subject[0, 0]).to eql ChunkyPNG::Color::BLACK
     end
-    
+
     it "should draw the rectangle fill only if the coordinates are fully out of bounds" do
       subject.rect(-1, -1, 20, 20, :black, :white)
-      subject[0, 0].should == ChunkyPNG::Color::WHITE
+      expect(subject[0, 0]).to eql ChunkyPNG::Color::WHITE
     end
   end
-  
+
   describe '#circle' do
-    subject { ChunkyPNG::Canvas.new(32, 32, ChunkyPNG::Color.rgba(0, 0, 255, 128)) } 
-    
+    subject { ChunkyPNG::Canvas.new(32, 32, ChunkyPNG::Color.rgba(0, 0, 255, 128)) }
+
     it "should draw circles" do
       subject.circle(11, 11, 10, ChunkyPNG::Color('red @ 0.5'), ChunkyPNG::Color('white @ 0.2'))
       subject.circle(21, 21, 10, ChunkyPNG::Color('green @ 0.5'))
-      subject.should == reference_canvas('circles')
+      expect(subject).to eql reference_canvas('circles')
     end
-    
+
     it "should draw partial circles when going of the canvas bounds" do
       subject.circle(0, 0, 10, ChunkyPNG::Color(:red))
       subject.circle(31, 16, 10, ChunkyPNG::Color(:black), ChunkyPNG::Color(:white, 0xaa))
-      subject.should == reference_canvas('partial_circles')
+      expect(subject).to eql reference_canvas('partial_circles')
     end
 
     it "should return itself to allow chaining" do
-      subject.circle(10, 10, 5, :red).should equal(subject)
+      expect(subject.circle(10, 10, 5, :red)).to equal(subject)
     end
   end
-  
+
   describe '#polygon' do
     subject { ChunkyPNG::Canvas.new(22, 22) }
 
     it "should draw an filled triangle when using 3 control points" do
       subject.polygon('(2,2) (20,5) (5,20)', ChunkyPNG::Color(:black, 0xaa), ChunkyPNG::Color(:red, 0x44))
-      subject.should == reference_canvas('polygon_triangle_filled')
+      expect(subject).to eql reference_canvas('polygon_triangle_filled')
     end
 
     it "should draw a unfilled polygon with 6 control points" do
       subject.polygon('(2,2) (12, 1) (20,5) (18,18) (5,20) (1,12)', ChunkyPNG::Color(:black))
-      subject.should == reference_canvas('polygon_unfilled')
+      expect(subject).to eql reference_canvas('polygon_unfilled')
     end
-    
+
     it "should draw a vertically crossed filled polygon with 4 control points" do
       subject.polygon('(2,2) (21,2) (2,21) (21,21)', ChunkyPNG::Color(:black), ChunkyPNG::Color(:red))
-      subject.should == reference_canvas('polygon_filled_vertical')
+      expect(subject).to eql reference_canvas('polygon_filled_vertical')
     end
 
     it "should draw a vertically crossed filled polygon with 4 control points" do
       subject.polygon('(2,2) (2,21) (21,2) (21,21)', ChunkyPNG::Color(:black), ChunkyPNG::Color(:red))
-      subject.should == reference_canvas('polygon_filled_horizontal')
+      expect(subject).to eql reference_canvas('polygon_filled_horizontal')
     end
 
     it "should return itself to allow chaining" do
-      subject.polygon('(2,2) (20,5) (5,20)').should equal(subject)
+      expect(subject.polygon('(2,2) (20,5) (5,20)')).to equal(subject)
     end
   end
-  
+
   describe '#bezier_curve' do
     subject { ChunkyPNG::Canvas.new(24, 24, ChunkyPNG::Color::WHITE) }
-    
+
     it "should draw a bezier curve starting at the first point" do
       subject.bezier_curve('3,20 10,10, 20,20')
-      subject[3, 20].should == ChunkyPNG::Color::BLACK
+      expect(subject[3, 20]).to eql ChunkyPNG::Color::BLACK
     end
-    
+
     it "should draw a bezier curve ending at the last point" do
       subject.bezier_curve('3,20 10,10, 20,20')
-      subject[20, 20].should == ChunkyPNG::Color::BLACK
+      expect(subject[20, 20]).to eql ChunkyPNG::Color::BLACK
     end
-    
+
     it "should draw a bezier curve with a color of green" do
       subject.bezier_curve('3,20 10,10, 20,20', :green)
-      subject[3, 20].should == ChunkyPNG::Color(:green)
+      expect(subject[3, 20]).to eql ChunkyPNG::Color(:green)
     end
-    
+
     it "should draw a three point bezier curve" do
-      subject.bezier_curve('1,23 12,10 23,23').should == reference_canvas('bezier_three_point')
+      expect(subject.bezier_curve('1,23 12,10 23,23')).to eql reference_canvas('bezier_three_point')
     end
-    
+
     it "should draw a three point bezier curve flipped" do
-      subject.bezier_curve('1,1 12,15 23,1').should == reference_canvas('bezier_three_point_flipped')
+      expect(subject.bezier_curve('1,1 12,15 23,1')).to eql reference_canvas('bezier_three_point_flipped')
     end
-    
+
     it "should draw a four point bezier curve" do
-      subject.bezier_curve('1,23 1,5 22,5 22,23').should == reference_canvas('bezier_four_point')
+      expect(subject.bezier_curve('1,23 1,5 22,5 22,23')).to eql reference_canvas('bezier_four_point')
     end
-    
+
     it "should draw a four point bezier curve flipped" do
-      subject.bezier_curve('1,1 1,19 22,19 22,1').should == reference_canvas('bezier_four_point_flipped')
+      expect(subject.bezier_curve('1,1 1,19 22,19 22,1')).to eql reference_canvas('bezier_four_point_flipped')
     end
-    
+
     it "should draw a four point bezier curve with a shape of an s" do
-      subject.bezier_curve('1,23 1,5 22,23 22,5').should == reference_canvas('bezier_four_point_s')
+      expect(subject.bezier_curve('1,23 1,5 22,23 22,5')).to eql reference_canvas('bezier_four_point_s')
     end
-    
+
     it "should draw a five point bezier curve" do
-      subject.bezier_curve('10,23 1,10 12,5 23,10 14,23').should == reference_canvas('bezier_five_point')
+      expect(subject.bezier_curve('10,23 1,10 12,5 23,10 14,23')).to eql reference_canvas('bezier_five_point')
     end
-    
+
     it "should draw a six point bezier curve" do
-      subject.bezier_curve('1,23 4,15 8,20 2,2 23,15 23,1').should == reference_canvas('bezier_six_point')
+      expect(subject.bezier_curve('1,23 4,15 8,20 2,2 23,15 23,1')).to eql reference_canvas('bezier_six_point')
     end
   end
 end

data/spec/chunky_png/canvas/masking_spec.rb

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

data/spec/chunky_png/canvas/operations_spec.rb

@@ -10,28 +10,28 @@ describe ChunkyPNG::Canvas::Operations do
     end
 
     it "should convert the image correctly" do
-      subject.grayscale.should == reference_canvas('operations_grayscale')
+      expect(subject.grayscale).to eql reference_canvas('operations_grayscale')
     end
 
     it "should not adjust the current image" do
-      lambda { subject.grayscale }.should_not change(subject, :pixels)
+      expect { subject.grayscale }.to_not change { subject.pixels }
     end
   end
 
   describe '#grayscale!' do
     it "should return itself" do
-      subject.grayscale!.should equal(subject)
+      expect(subject.grayscale!).to equal(subject)
     end
 
     it "should convert the image correctly" do
       subject.grayscale!
-      subject.should == reference_canvas('operations_grayscale')
+      expect(subject).to eql reference_canvas('operations_grayscale')
     end
   end
 
   describe '#crop' do
     it "should crop the right pixels from the original canvas" do
-      subject.crop(10, 5, 4, 8).should == reference_canvas('cropped')
+      expect(subject.crop(10, 5, 4, 8)).to eql reference_canvas('cropped')
     end
 
     it "should not return itself" do
@@ -39,44 +39,43 @@ describe ChunkyPNG::Canvas::Operations do
     end
 
     it "should not adjust the current image" do
-      lambda { subject.crop(10, 5, 4, 8) }.should_not change(subject, :pixels)
+      expect { subject.crop(10, 5, 4, 8) }.to_not change { subject.pixels }
     end
 
     it "should raise an exception when the cropped image falls outside the oiginal image" do
-      lambda { subject.crop(16, 16, 2, 2) }.should raise_error(ChunkyPNG::OutOfBounds)
+      expect { subject.crop(16, 16, 2, 2) }.to raise_error(ChunkyPNG::OutOfBounds)
     end
   end
 
   describe '#crop!' do
     it "should crop the right pixels from the original canvas" do
       subject.crop!(10, 5, 4, 8)
-      subject.should == reference_canvas('cropped')
+      expect(subject).to eql reference_canvas('cropped')
     end
 
     it "should have a new width and height" do
-      lambda { subject.crop!(10, 5, 4, 8) }.should change(subject, :dimension).
-          from(ChunkyPNG::Dimension('16x16')).
-          to(ChunkyPNG::Dimension('4x8'))
+      expect { subject.crop!(10, 5, 4, 8) }.to change { subject.dimension }.
+          from(ChunkyPNG::Dimension('16x16')).to(ChunkyPNG::Dimension('4x8'))
     end
 
     it "should raise an exception when the cropped image falls outside the oiginal image" do
-      lambda { subject.crop!(16, 16, 2, 2) }.should raise_error(ChunkyPNG::OutOfBounds)
+      expect { subject.crop!(16, 16, 2, 2) }.to raise_error(ChunkyPNG::OutOfBounds)
     end
 
     it "should return itself" do
-      subject.crop!(10, 5, 4, 8).should equal(subject)
+      expect(subject.crop!(10, 5, 4, 8)).to equal(subject)
     end
   end
 
   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).should == 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))
-      subject.should == reference_canvas('operations')
+      expect(subject).to eql reference_canvas('operations')
     end
 
     it "should not return itself" do
@@ -84,7 +83,7 @@ describe ChunkyPNG::Canvas::Operations do
     end
 
     it "should raise an exception when the pixels to compose fall outside the image" do
-      lambda { subject.compose(ChunkyPNG::Canvas.new(1,1), 16, 16) }.should raise_error(ChunkyPNG::OutOfBounds)
+      expect { subject.compose(ChunkyPNG::Canvas.new(1,1), 16, 16) }.to raise_error(ChunkyPNG::OutOfBounds)
     end
   end
 
@@ -92,29 +91,29 @@ describe ChunkyPNG::Canvas::Operations 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)
-      subject.should == reference_canvas('composited')
+      expect(subject).to eql reference_canvas('composited')
     end
 
     it "should return itself" do
-      subject.compose!(ChunkyPNG::Canvas.new(1,1)).should 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.compose!(mask)
-      base.should == 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
-      lambda { subject.compose!(ChunkyPNG::Canvas.new(1,1), 16, 16) }.should raise_error(ChunkyPNG::OutOfBounds)
+      expect { subject.compose!(ChunkyPNG::Canvas.new(1,1), 16, 16) }.to raise_error(ChunkyPNG::OutOfBounds)
     end
   end
 
   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).should == reference_canvas('replaced')
+      expect(subject.replace(subcanvas, 5, 4)).to eql reference_canvas('replaced')
     end
 
     it "should not return itself" do
@@ -123,11 +122,11 @@ describe ChunkyPNG::Canvas::Operations do
 
     it "should leave the original intact" do
       subject.replace(ChunkyPNG::Canvas.new(1,1))
-      subject.should == reference_canvas('operations')
+      expect(subject).to eql reference_canvas('operations')
     end
 
     it "should raise an exception when the pixels to replace fall outside the image" do
-      lambda { subject.replace(ChunkyPNG::Canvas.new(1,1), 16, 16) }.should raise_error(ChunkyPNG::OutOfBounds)
+      expect { subject.replace(ChunkyPNG::Canvas.new(1,1), 16, 16) }.to raise_error(ChunkyPNG::OutOfBounds)
     end
   end
 
@@ -135,15 +134,15 @@ describe ChunkyPNG::Canvas::Operations 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)
-      subject.should == reference_canvas('replaced')
+      expect(subject).to eql reference_canvas('replaced')
     end
 
     it "should return itself" do
-      subject.replace!(ChunkyPNG::Canvas.new(1,1)).should 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
-      lambda { subject.replace!(ChunkyPNG::Canvas.new(1,1), 16, 16) }.should raise_error(ChunkyPNG::OutOfBounds)
+      expect { subject.replace!(ChunkyPNG::Canvas.new(1,1), 16, 16) }.to raise_error(ChunkyPNG::OutOfBounds)
     end
   end
 end
@@ -155,17 +154,17 @@ describe ChunkyPNG::Canvas::Operations do
   describe '#flip_horizontally!' do
     it "should flip the pixels horizontally in place" do
       subject.flip_horizontally!
-      subject.should == ChunkyPNG::Canvas.new(2, 3, [5, 6, 3, 4, 1, 2])
+      expect(subject).to eql ChunkyPNG::Canvas.new(2, 3, [5, 6, 3, 4, 1, 2])
     end
 
     it "should return itself" do
-      subject.flip_horizontally!.should equal(subject)
+      expect(subject.flip_horizontally!).to equal(subject)
     end
   end
 
   describe '#flip_horizontally' do
     it "should flip the pixels horizontally" do
-      subject.flip_horizontally.should == ChunkyPNG::Canvas.new(2, 3, [5, 6, 3, 4, 1, 2])
+      expect(subject.flip_horizontally).to eql ChunkyPNG::Canvas.new(2, 3, [5, 6, 3, 4, 1, 2])
     end
 
     it "should not return itself" do
@@ -173,24 +172,24 @@ describe ChunkyPNG::Canvas::Operations do
     end
 
     it "should return a copy of itself when applied twice" do
-      subject.flip_horizontally.flip_horizontally.should == subject
+      expect(subject.flip_horizontally.flip_horizontally).to eql subject
     end
   end
 
   describe '#flip_vertically!' do
     it "should flip the pixels vertically" do
       subject.flip_vertically!
-      subject.should == ChunkyPNG::Canvas.new(2, 3, [2, 1, 4, 3, 6, 5])
+      expect(subject).to eql ChunkyPNG::Canvas.new(2, 3, [2, 1, 4, 3, 6, 5])
     end
 
     it "should return itself" do
-      subject.flip_horizontally!.should equal(subject)
+      expect(subject.flip_horizontally!).to equal(subject)
     end
   end
 
   describe '#flip_vertically' do
     it "should flip the pixels vertically" do
-      subject.flip_vertically.should == ChunkyPNG::Canvas.new(2, 3, [2, 1, 4, 3, 6, 5])
+      expect(subject.flip_vertically).to eql ChunkyPNG::Canvas.new(2, 3, [2, 1, 4, 3, 6, 5])
     end
 
     it "should not return itself" do
@@ -198,13 +197,13 @@ describe ChunkyPNG::Canvas::Operations do
     end
 
     it "should return a copy of itself when applied twice" do
-      subject.flip_vertically.flip_vertically.should == subject
+      expect(subject.flip_vertically.flip_vertically).to eql subject
     end
   end
 
   describe '#rotate_left' do
     it "should rotate the pixels 90 degrees counter-clockwise" do
-      subject.rotate_left.should == 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
@@ -212,40 +211,41 @@ describe ChunkyPNG::Canvas::Operations do
     end
 
     it "should not change the image dimensions" do
-      lambda { subject.rotate_left }.should_not change(subject, :dimension)
+      expect { subject.rotate_left }.to_not change { subject.dimension }
     end
 
     it "it should rotate 180 degrees when applied twice" do
-      subject.rotate_left.rotate_left.should == subject.rotate_180
+      expect(subject.rotate_left.rotate_left).to eql subject.rotate_180
     end
 
     it "it should rotate right when applied three times" do
-      subject.rotate_left.rotate_left.rotate_left.should == subject.rotate_right
+      expect(subject.rotate_left.rotate_left.rotate_left).to eql subject.rotate_right
     end
 
     it "should return itself when applied four times" do
-      subject.rotate_left.rotate_left.rotate_left.rotate_left.should == subject
+      expect(subject.rotate_left.rotate_left.rotate_left.rotate_left).to eql subject
     end
   end
 
   describe '#rotate_left!' do
     it "should rotate the pixels 90 degrees clockwise" do
       subject.rotate_left!
-      subject.should == 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
-      subject.rotate_left!.should equal(subject)
+      expect(subject.rotate_left!).to equal(subject)
     end
 
     it "should change the image dimensions" do
-      lambda { subject.rotate_left! }.should 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
     it "should rotate the pixels 90 degrees clockwise" do
-      subject.rotate_right.should == 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
@@ -253,40 +253,41 @@ describe ChunkyPNG::Canvas::Operations do
     end
 
     it "should not change the image dimensions" do
-      lambda { subject.rotate_right }.should_not change(subject, :dimension)
+      expect { subject.rotate_right }.to_not change { subject.dimension }
     end
 
     it "it should rotate 180 degrees when applied twice" do
-      subject.rotate_right.rotate_right.should == subject.rotate_180
+      expect(subject.rotate_right.rotate_right).to eql subject.rotate_180
     end
 
     it "it should rotate left when applied three times" do
-      subject.rotate_right.rotate_right.rotate_right.should == subject.rotate_left
+      expect(subject.rotate_right.rotate_right.rotate_right).to eql subject.rotate_left
     end
 
     it "should return itself when applied four times" do
-      subject.rotate_right.rotate_right.rotate_right.rotate_right.should == subject
+      expect(subject.rotate_right.rotate_right.rotate_right.rotate_right).to eql subject
     end
   end
 
   describe '#rotate_right!' do
     it "should rotate the pixels 90 degrees clockwise" do
       subject.rotate_right!
-      subject.should == 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
-      subject.rotate_right!.should equal(subject)
+      expect(subject.rotate_right!).to equal(subject)
     end
 
     it "should change the image dimensions" do
-      lambda { subject.rotate_right! }.should 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
     it "should rotate the pixels 180 degrees" do
-      subject.rotate_180.should == ChunkyPNG::Canvas.new(2, 3, [6, 5, 4, 3, 2, 1])
+      expect(subject.rotate_180).to eql ChunkyPNG::Canvas.new(2, 3, [6, 5, 4, 3, 2, 1])
     end
 
     it "should return not itself" do
@@ -294,18 +295,18 @@ describe ChunkyPNG::Canvas::Operations do
     end
 
     it "should return a copy of itself when applied twice" do
-      subject.rotate_180.rotate_180.should == subject
+      expect(subject.rotate_180.rotate_180).to eql subject
     end
   end
 
   describe '#rotate_180!' do
     it "should rotate the pixels 180 degrees" do
       subject.rotate_180!
-      subject.should == ChunkyPNG::Canvas.new(2, 3, [6, 5, 4, 3, 2, 1])
+      expect(subject).to eql ChunkyPNG::Canvas.new(2, 3, [6, 5, 4, 3, 2, 1])
     end
 
     it "should return itself" do
-      subject.rotate_180!.should equal(subject)
+      expect(subject.rotate_180!).to equal(subject)
     end
   end
 end
@@ -316,7 +317,7 @@ describe ChunkyPNG::Canvas::Operations do
 
   describe "#trim" do
     it "should trim the border" do
-      subject.trim.should == ChunkyPNG::Canvas.new(2, 2, 255)
+      expect(subject.trim).to eql ChunkyPNG::Canvas.new(2, 2, 255)
     end
 
     it "should not return itself" do
@@ -324,26 +325,27 @@ describe ChunkyPNG::Canvas::Operations do
     end
 
     it "should be able to fail to trim a specified color" do
-      lambda { subject.trim(ChunkyPNG::Color::BLACK) }.should_not change(subject, :pixels)
+      expect { subject.trim(ChunkyPNG::Color::BLACK) }.to_not change { subject.pixels }
     end
 
     it "should be the same after trimming an added border" do
-      subject.border(2).trim.should == subject
+      expect(subject.border(2).trim).to eql subject
     end
   end
 
   describe "#trim!" do
     it "should trim the border" do
       subject.trim!
-      subject.should == ChunkyPNG::Canvas.new(2, 2, 255)
+      expect(subject).to eql ChunkyPNG::Canvas.new(2, 2, 255)
     end
 
     it "should return itself" do
-      subject.trim!.should equal(subject)
+      expect(subject.trim!).to equal(subject)
     end
 
     it "should change the image dimensions" do
-      lambda { subject.trim! }.should 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
@@ -354,7 +356,7 @@ describe ChunkyPNG::Canvas::Operations do
 
   describe "#border" do
     it "should add the border" do
-      subject.border(2).should == reference_canvas('operations_border')
+      expect(subject.border(2)).to eql reference_canvas('operations_border')
     end
 
     it "should not return itself" do
@@ -362,27 +364,28 @@ describe ChunkyPNG::Canvas::Operations do
     end
 
     it "should retain transparency" do
-      ChunkyPNG::Canvas.new(1, 1).border(1).pixels.should include(0)
+      expect(ChunkyPNG::Canvas.new(1, 1).border(1).pixels).to include(0)
     end
   end
 
   describe "#border!" do
     it "should add the border" do
       subject.border!(2)
-      subject.should == reference_canvas('operations_border')
+      expect(subject).to eql reference_canvas('operations_border')
     end
 
     it "should return itself" do
-      subject.border!(1).should equal(subject)
+      expect(subject.border!(1)).to equal(subject)
     end
 
     it "should retain transparency" do
       subject.border!(1)
-      subject.pixels.should include(0)
+      expect(subject.pixels).to include(0)
     end
 
     it "should change the image dimensions" do
-      lambda { subject.border!(1) }.should 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