oily_png 1.1.2 → 1.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 1b84a04e46948ddd4be00b39c9875a2ab28f20b1
-  data.tar.gz: 75442b85ad8fde3f8bed8a49767c4b03739ff469
+  metadata.gz: 8ac04ee8bba389a3335e3c2bab7d541669e007ca
+  data.tar.gz: 82a58ceea811af07716f47806b6e3470ade19016
 SHA512:
-  metadata.gz: 2df5b8e3fdcb0c7bc55021231cbc06b077892de1a0cea5cdcbda979bdc7f94875a980520c67ca2e786c2ef5fb68780988c93d5ccf4e650bf67bbd108e3363ecf
-  data.tar.gz: 70137f6debdd292c3b9bc5b443e740e849fef83ec35175e154f8b0feb84211537dab1508b0f5427ac23f182c8e917df583a1bd6d3c1236ce2c163fb36a92cbb1
+  metadata.gz: 3758ec87e787a7990bccb674241ef46eb4678226bfb745e08926c25227bc3d5254faaf7502b2ec067e3ba9052770cdcca8272f01abc2d96aa499474c91fa388e
+  data.tar.gz: 6468851a2871e1309457b51288fe8b33f35f52296f2a528d10574fc8758f01ae7b91c2ab685157b557e603014c89301a2c6351d5c1950fedc4f0adf9827dc60c

data/ext/oily_png/oily_png_ext.c

@@ -30,6 +30,8 @@ void Init_oily_png() {
   VALUE OilyPNG_Operations = rb_define_module_under(OilyPNG, "Operations");
   rb_define_method(OilyPNG_Operations, "compose!", oily_png_compose_bang, -1);
   rb_define_method(OilyPNG_Operations, "replace!", oily_png_replace_bang, -1);
+  rb_define_method(OilyPNG_Operations, "rotate_left!", oily_png_rotate_left_bang, 0);
+  rb_define_method(OilyPNG_Operations, "rotate_right!", oily_png_rotate_right_bang, 0);
 }
 
 char oily_png_samples_per_pixel(char color_mode) {

data/ext/oily_png/operations.c

@@ -120,3 +120,41 @@ VALUE oily_png_replace_bang(int argc, VALUE *argv, VALUE self) {
   }
   return self;
 }
+
+VALUE oily_png_rotate_left_bang(VALUE self){
+  int store_at;
+  VALUE pixel_value;
+  int canvas_width = NUM2INT(rb_funcall(self, rb_intern("width"), 0));
+  int canvas_height = NUM2INT(rb_funcall(self, rb_intern("height"), 0));
+  VALUE original_pixels = rb_funcall(self, rb_intern("pixels"), 0);
+  VALUE new_pixels = rb_ary_dup(original_pixels);
+  int i, j;
+  for( j = 0 ; j < canvas_width; j++ ){
+    for( i = 0 ; i < canvas_height; i++ ){
+      store_at = (canvas_width - 1 - j)*canvas_height + i;
+      pixel_value = rb_ary_entry(original_pixels, i*canvas_width + j);
+      rb_ary_store(new_pixels, store_at, pixel_value );
+    }
+  }
+  rb_funcall(self, rb_intern("replace_canvas!"), 3, INT2NUM(canvas_height), INT2NUM(canvas_width), new_pixels);
+  return self;
+}
+
+VALUE oily_png_rotate_right_bang(VALUE self){
+  int store_at;
+  VALUE pixel_value;
+  int canvas_width = NUM2INT(rb_funcall(self, rb_intern("width"), 0));
+  int canvas_height = NUM2INT(rb_funcall(self, rb_intern("height"), 0));
+  VALUE original_pixels = rb_funcall(self, rb_intern("pixels"), 0);
+  VALUE new_pixels = rb_ary_dup(original_pixels);
+  int i, j;
+  for( j = 0; j < canvas_width; j++ ){
+    for( i = 0; i < canvas_height; i++ ){
+      store_at = j * canvas_height + (canvas_height - i - 1);
+      pixel_value = rb_ary_entry(original_pixels, i*canvas_width + j);
+      rb_ary_store(new_pixels, store_at, pixel_value );
+    }
+  }
+  rb_funcall(self, rb_intern("replace_canvas!"), 3, INT2NUM(canvas_height), INT2NUM(canvas_width), new_pixels);
+  return self;
+}

data/ext/oily_png/operations.h

@@ -33,4 +33,15 @@ VALUE oily_png_compose_bang(int argc, VALUE *argv, VALUE c);
 */
 VALUE oily_png_replace_bang(int argc, VALUE *argv, VALUE c);
 
+
+/*
+  C replacement method for rotating the image 90 degrees counter-clockwise.
+*/
+VALUE oily_png_rotate_left_bang(VALUE self);
+
+/*
+  C replacement method for rotating the image 90 degrees clockwise.
+*/
+VALUE oily_png_rotate_right_bang(VALUE self);
+
 #endif

data/lib/oily_png.rb

@@ -10,6 +10,7 @@ module OilyPNG
     
     base::Color.extend OilyPNG::Color
     base::Canvas.send(:include, OilyPNG::Resampling)
+    base::Canvas.send(:include, OilyPNG::Operations)
   end
 end
 

data/lib/oily_png/version.rb

@@ -1,3 +1,3 @@
 module OilyPNG
-  VERSION = "1.1.2"
+  VERSION = "1.2.0"
 end

data/oily_png.gemspec

@@ -29,7 +29,7 @@ Gem::Specification.new do |s|
 
   s.add_development_dependency('rake')
   s.add_development_dependency('rake-compiler')
-  s.add_development_dependency('rspec', '~> 2')
+  s.add_development_dependency('rspec', '~> 3')
 
   s.rdoc_options << '--title' << s.name << '--main' << 'README.rdoc' << '--line-numbers' << '--inline-source'
   s.extra_rdoc_files = ['README.rdoc']

data/spec/color_spec.rb

@@ -13,24 +13,24 @@ describe OilyPNG::Color do
 
   describe '#compose_quick' do
     it 'should use the foregorund color as is when the background color is fully transparent' do
-      compose_quick(@non_opaque, @fully_transparent).should == @non_opaque
+      expect(compose_quick(@non_opaque, @fully_transparent)).to be(@non_opaque)
     end
 
     it 'should use the foregorund color as is when an opaque color is given as foreground color' do
-      compose_quick(@opaque, @white).should == @opaque
+      expect(compose_quick(@opaque, @white)).to be(@opaque)
     end
 
     it 'should use the background color as is when a fully transparent pixel is given as foreground color' do
-      compose_quick(@fully_transparent, @white).should == @white
+      expect(compose_quick(@fully_transparent, @white)).to be(@white)
     end
 
     it 'should compose pixels correctly' do
-      compose_quick(@non_opaque, @white).should == 0x9fc2d6ff
+      expect(compose_quick(@non_opaque, @white)).to be(0x9fc2d6ff)
     end
 
     it 'should compose colors exactly the same as ChunkyPNG' do
       fg, bg = rand(0xffffffff), rand(0xffffffff)
-      compose_quick(fg, bg).should == ChunkyPNG::Color.compose_quick(fg, bg)
+      expect(compose_quick(fg, bg)).to be(ChunkyPNG::Color.compose_quick(fg, bg))
     end
   end
 
@@ -39,11 +39,11 @@ describe OilyPNG::Color do
     let(:color_b) { rand(0xffffffff) }
     subject { euclidean_distance_rgba(color_a, color_b) }
 
-    it { should == ChunkyPNG::Color.euclidean_distance_rgba(color_a, color_b) }
+    it { is_expected.to eq(ChunkyPNG::Color.euclidean_distance_rgba(color_a, color_b)) }
 
     context 'when both colors are the same' do
       let(:color_b) { color_a }
-      it { should == 0 }
+      it { is_expected.to eq(0) }
     end
   end
 end

data/spec/decoding_spec.rb

@@ -3,12 +3,12 @@ require 'spec_helper'
 describe OilyPNG::PNGDecoding do
 
   it "should call ChunkyPNG::Color.pixel_bytesize in the pure ruby version" do
-    ChunkyPNG::Color.should_receive(:pixel_bytesize).and_return(3)
+    expect(ChunkyPNG::Color).to receive(:pixel_bytesize).and_return(3)
     ChunkyPNG::Canvas.from_file(resource_file('square.png'))
   end
 
   it "should not call ChunkyPNG::Color.pixel_bytesize in the native version" do
-    ChunkyPNG::Color.should_not_receive(:pixel_bytesize)
+    expect(ChunkyPNG::Color).to receive(:pixel_bytesize).never
     OilyPNG::Canvas.from_file(resource_file('square.png'))
   end
   
@@ -17,34 +17,34 @@ describe OilyPNG::PNGDecoding do
     
     it "should decode NONE filtering exactly the same as ChunkyPNG" do
       filtered_data = @reference.to_blob(:filtering => ChunkyPNG::FILTER_NONE)
-      ChunkyPNG::Canvas.from_blob(filtered_data).should == OilyPNG::Canvas.from_blob(filtered_data)
+      expect(ChunkyPNG::Canvas.from_blob(filtered_data)).to eq(OilyPNG::Canvas.from_blob(filtered_data))
     end
     
     it "should decode SUB filtering exactly the same as ChunkyPNG" do
       filtered_data = @reference.to_blob(:filtering => ChunkyPNG::FILTER_SUB)
-      ChunkyPNG::Canvas.from_blob(filtered_data).should == OilyPNG::Canvas.from_blob(filtered_data)
+      expect(ChunkyPNG::Canvas.from_blob(filtered_data)).to eq(OilyPNG::Canvas.from_blob(filtered_data))
     end
     
     it "should decode UP filtering exactly the same as ChunkyPNG" do
       filtered_data = @reference.to_blob(:filtering => ChunkyPNG::FILTER_UP)
-      ChunkyPNG::Canvas.from_blob(filtered_data).should == OilyPNG::Canvas.from_blob(filtered_data)
+      expect(ChunkyPNG::Canvas.from_blob(filtered_data)).to eq(OilyPNG::Canvas.from_blob(filtered_data))
     end
     
     it "should decode AVERAGE filtering exactly the same as ChunkyPNG" do
       filtered_data = @reference.to_blob(:filtering => ChunkyPNG::FILTER_AVERAGE)
-      ChunkyPNG::Canvas.from_blob(filtered_data).should == OilyPNG::Canvas.from_blob(filtered_data)
+      expect(ChunkyPNG::Canvas.from_blob(filtered_data)).to eq(OilyPNG::Canvas.from_blob(filtered_data))
     end
     
     it "should decode PAETH filtering exactly the same as ChunkyPNG" do
       filtered_data = @reference.to_blob(:filtering => ChunkyPNG::FILTER_PAETH)
-      ChunkyPNG::Canvas.from_blob(filtered_data).should == OilyPNG::Canvas.from_blob(filtered_data)
+      expect(ChunkyPNG::Canvas.from_blob(filtered_data)).to eq(OilyPNG::Canvas.from_blob(filtered_data))
     end
   end
   
   context 'decoding compatibility with ChunkyPNG' do
     resource_files.each do |file|
       it "should #{File.basename(file)} the same as ChunkyPNG" do
-        OilyPNG::Canvas.from_file(file).pixels.should == ChunkyPNG::Canvas.from_file(file).pixels
+        expect(OilyPNG::Canvas.from_file(file).pixels).to eq(ChunkyPNG::Canvas.from_file(file).pixels)
       end
     end
   end

data/spec/encoding_spec.rb

@@ -11,43 +11,43 @@ describe OilyPNG::PNGEncoding do
     it "should encode an image using 8-bit grayscale correctly" do
       @canvas.send(:encode_png_image_pass_to_stream,      stream2 = ChunkyPNG::Datastream.empty_bytearray, ChunkyPNG::COLOR_GRAYSCALE, 8, ChunkyPNG::FILTER_NONE)
       @oily_canvas.send(:encode_png_image_pass_to_stream, stream1 = ChunkyPNG::Datastream.empty_bytearray, ChunkyPNG::COLOR_GRAYSCALE, 8, ChunkyPNG::FILTER_NONE)
-      stream1.should == stream2
+      expect(stream1).to eq(stream2)
     end
     
     it "should encode an image using 4-bit grayscale correctly" do
       @canvas.send(:encode_png_image_pass_to_stream,      stream2 = ChunkyPNG::Datastream.empty_bytearray, ChunkyPNG::COLOR_GRAYSCALE, 4, ChunkyPNG::FILTER_NONE)
       @oily_canvas.send(:encode_png_image_pass_to_stream, stream1 = ChunkyPNG::Datastream.empty_bytearray, ChunkyPNG::COLOR_GRAYSCALE, 4, ChunkyPNG::FILTER_NONE)
-      stream1.should == stream2
+      expect(stream1).to eq(stream2)
     end
     
     it "should encode an image using 2-bit grayscale correctly" do
       @canvas.send(:encode_png_image_pass_to_stream,      stream2 = ChunkyPNG::Datastream.empty_bytearray, ChunkyPNG::COLOR_GRAYSCALE, 2, ChunkyPNG::FILTER_NONE)
       @oily_canvas.send(:encode_png_image_pass_to_stream, stream1 = ChunkyPNG::Datastream.empty_bytearray, ChunkyPNG::COLOR_GRAYSCALE, 2, ChunkyPNG::FILTER_NONE)
-      stream1.should == stream2
+      expect(stream1).to eq(stream2)
     end
     
     it "should encode an image using 1-bit grayscale correctly" do
       @canvas.send(:encode_png_image_pass_to_stream,      stream2 = ChunkyPNG::Datastream.empty_bytearray, ChunkyPNG::COLOR_GRAYSCALE, 1, ChunkyPNG::FILTER_NONE)
       @oily_canvas.send(:encode_png_image_pass_to_stream, stream1 = ChunkyPNG::Datastream.empty_bytearray, ChunkyPNG::COLOR_GRAYSCALE, 1, ChunkyPNG::FILTER_NONE)
-      stream1.should == stream2
+      expect(stream1).to eq(stream2)
     end
     
     it "should encode an image using 8-bit grayscale alpha correctly" do
       @oily_canvas.send(:encode_png_image_pass_to_stream, stream1 = ChunkyPNG::Datastream.empty_bytearray, ChunkyPNG::COLOR_GRAYSCALE_ALPHA, 8, ChunkyPNG::FILTER_NONE)
       @canvas.send(:encode_png_image_pass_to_stream,      stream2 = ChunkyPNG::Datastream.empty_bytearray, ChunkyPNG::COLOR_GRAYSCALE_ALPHA, 8, ChunkyPNG::FILTER_NONE)
-      stream1.should == stream2
+      expect(stream1).to eq(stream2)
     end
 
     it "should encode an image using 8-bit truecolor correctly" do
       @oily_canvas.send(:encode_png_image_pass_to_stream, stream1 = ChunkyPNG::Datastream.empty_bytearray, ChunkyPNG::COLOR_TRUECOLOR, 8, ChunkyPNG::FILTER_NONE)
       @canvas.send(:encode_png_image_pass_to_stream,      stream2 = ChunkyPNG::Datastream.empty_bytearray, ChunkyPNG::COLOR_TRUECOLOR, 8, ChunkyPNG::FILTER_NONE)
-      stream1.should == stream2
+      expect(stream1).to eq(stream2)
     end
     
     it "should encode an image using 8-bit truecolor alpha correctly" do
       @oily_canvas.send(:encode_png_image_pass_to_stream, stream1 = ChunkyPNG::Datastream.empty_bytearray, ChunkyPNG::COLOR_TRUECOLOR_ALPHA, 8, ChunkyPNG::FILTER_NONE)
       @canvas.send(:encode_png_image_pass_to_stream,      stream2 = ChunkyPNG::Datastream.empty_bytearray, ChunkyPNG::COLOR_TRUECOLOR_ALPHA, 8, ChunkyPNG::FILTER_NONE)
-      stream1.should == stream2
+      expect(stream1).to eq(stream2)
     end
   end
 
@@ -66,25 +66,25 @@ describe OilyPNG::PNGEncoding do
     it "should encode an image using 8-bit indexed colors correctly" do
       @canvas.send(:encode_png_image_pass_to_stream,      stream2 = ChunkyPNG::Datastream.empty_bytearray, ChunkyPNG::COLOR_INDEXED, 8, ChunkyPNG::FILTER_NONE)
       @oily_canvas.send(:encode_png_image_pass_to_stream, stream1 = ChunkyPNG::Datastream.empty_bytearray, ChunkyPNG::COLOR_INDEXED, 8, ChunkyPNG::FILTER_NONE)
-      stream1.should == stream2
+      expect(stream1).to eq(stream2)
     end
 
     it "should encode an image using 4-bit indexed colors correctly" do
       @canvas.send(:encode_png_image_pass_to_stream,      stream2 = ChunkyPNG::Datastream.empty_bytearray, ChunkyPNG::COLOR_INDEXED, 4, ChunkyPNG::FILTER_NONE)
       @oily_canvas.send(:encode_png_image_pass_to_stream, stream1 = ChunkyPNG::Datastream.empty_bytearray, ChunkyPNG::COLOR_INDEXED, 4, ChunkyPNG::FILTER_NONE)
-      stream1.should == stream2
+      expect(stream1).to eq(stream2)
     end
 
     it "should encode an image using 2-bit indexed colors correctly" do
       @canvas.send(:encode_png_image_pass_to_stream,      stream2 = ChunkyPNG::Datastream.empty_bytearray, ChunkyPNG::COLOR_INDEXED, 2, ChunkyPNG::FILTER_NONE)
       @oily_canvas.send(:encode_png_image_pass_to_stream, stream1 = ChunkyPNG::Datastream.empty_bytearray, ChunkyPNG::COLOR_INDEXED, 2, ChunkyPNG::FILTER_NONE)
-      stream1.should == stream2
+      expect(stream1).to eq(stream2)
     end
 
     it "should encode an image using 1-bit indexed colors correctly" do
       @canvas.send(:encode_png_image_pass_to_stream,      stream2 = ChunkyPNG::Datastream.empty_bytearray, ChunkyPNG::COLOR_INDEXED, 1, ChunkyPNG::FILTER_NONE)
       @oily_canvas.send(:encode_png_image_pass_to_stream, stream1 = ChunkyPNG::Datastream.empty_bytearray, ChunkyPNG::COLOR_INDEXED, 1, ChunkyPNG::FILTER_NONE)
-      stream1.should == stream2
+      expect(stream1).to eq(stream2)
     end
   end
   
@@ -97,31 +97,31 @@ describe OilyPNG::PNGEncoding do
     it "should encode correctly with no filtering" do
       @oily_canvas.send(:encode_png_image_pass_to_stream, stream1 = ChunkyPNG::Datastream.empty_bytearray, ChunkyPNG::COLOR_TRUECOLOR, 8, ChunkyPNG::FILTER_NONE)
       @canvas.send(:encode_png_image_pass_to_stream,      stream2 = ChunkyPNG::Datastream.empty_bytearray, ChunkyPNG::COLOR_TRUECOLOR, 8, ChunkyPNG::FILTER_NONE)
-      stream1.should == stream2
+      expect(stream1).to eq(stream2)
     end
     
     it "should encode correctly with sub filtering" do
       @oily_canvas.send(:encode_png_image_pass_to_stream, stream1 = ChunkyPNG::Datastream.empty_bytearray, ChunkyPNG::COLOR_TRUECOLOR, 8, ChunkyPNG::FILTER_SUB)
       @canvas.send(:encode_png_image_pass_to_stream,      stream2 = ChunkyPNG::Datastream.empty_bytearray, ChunkyPNG::COLOR_TRUECOLOR, 8, ChunkyPNG::FILTER_SUB)
-      stream1.should == stream2
+      expect(stream1).to eq(stream2)
     end
     
     it "should encode correctly with up filtering" do
       @oily_canvas.send(:encode_png_image_pass_to_stream, stream1 = ChunkyPNG::Datastream.empty_bytearray, ChunkyPNG::COLOR_TRUECOLOR, 8, ChunkyPNG::FILTER_UP)
       @canvas.send(:encode_png_image_pass_to_stream,      stream2 = ChunkyPNG::Datastream.empty_bytearray, ChunkyPNG::COLOR_TRUECOLOR, 8, ChunkyPNG::FILTER_UP)
-      stream1.should == stream2
+      expect(stream1).to eq(stream2)
     end
     
     it "should encode correctly with average filtering" do
       @oily_canvas.send(:encode_png_image_pass_to_stream, stream1 = ChunkyPNG::Datastream.empty_bytearray, ChunkyPNG::COLOR_TRUECOLOR, 8, ChunkyPNG::FILTER_AVERAGE)
       @canvas.send(:encode_png_image_pass_to_stream,      stream2 = ChunkyPNG::Datastream.empty_bytearray, ChunkyPNG::COLOR_TRUECOLOR, 8, ChunkyPNG::FILTER_AVERAGE)
-      stream1.should == stream2
+      expect(stream1).to eq(stream2)
     end
     
     it "should encode correctly with paeth filtering" do
       @oily_canvas.send(:encode_png_image_pass_to_stream, stream1 = ChunkyPNG::Datastream.empty_bytearray, ChunkyPNG::COLOR_TRUECOLOR, 8, ChunkyPNG::FILTER_PAETH)
       @canvas.send(:encode_png_image_pass_to_stream,      stream2 = ChunkyPNG::Datastream.empty_bytearray, ChunkyPNG::COLOR_TRUECOLOR, 8, ChunkyPNG::FILTER_PAETH)
-      stream1.should == stream2
+      expect(stream1).to eq(stream2)
     end
   end
   
@@ -129,7 +129,7 @@ describe OilyPNG::PNGEncoding do
     canvas = ChunkyPNG::Canvas.from_file(resource_file('interlaced.png'))
     data = OilyPNG::Canvas.from_canvas(canvas).to_blob(:interlace => true)
     ds = ChunkyPNG::Datastream.from_blob(data)
-    ds.header_chunk.interlace.should == ChunkyPNG::INTERLACING_ADAM7
-    ChunkyPNG::Canvas.from_datastream(ds).should == canvas
+    expect(ds.header_chunk.interlace).to eq(ChunkyPNG::INTERLACING_ADAM7)
+    expect(ChunkyPNG::Canvas.from_datastream(ds)).to eq(canvas)
   end
 end

data/spec/operations_spec.rb

@@ -8,21 +8,21 @@ describe OilyPNG::Operations do
     it "should compose two images without offset exactly the same way as ChunkyPNG" do
       subcanvas = ChunkyPNG::Canvas.new(4, 8, ChunkyPNG::Color.rgba(0, 0, 0, 75))
       subject.compose!(subcanvas)
-      ChunkyPNG::Canvas.from_canvas(subject).should == reference_canvas('operations').compose(subcanvas)
+      expect(ChunkyPNG::Canvas.from_canvas(subject)).to eq(reference_canvas('operations').compose(subcanvas))
     end
 
     it "should compose two images with offset exactly the same way as ChunkyPNG" do
       subject.compose!(ChunkyPNG::Canvas.new(4, 8, ChunkyPNG::Color.rgba(0, 0, 0, 75)), 8, 4) 
-      subject.should == oily_reference_canvas('composited')
+      expect(subject).to eql(oily_reference_canvas('composited'))
     end
 
     it "should return itself" do
-      subject.compose!(OilyPNG::Canvas.new(1,1)).should equal(subject)
+      expect(subject.compose!(OilyPNG::Canvas.new(1,1))).to be(subject)
     end
 
     it "should raise an exception when the pixels to compose fall outside the image" do
       # For now this raises a runtime error, but it should probably raise a ChunkyPNG::OutOfBounds error
-      lambda { subject.compose!(OilyPNG::Canvas.new(1,1), 16, 16) }.should raise_error
+      expect { subject.compose!(OilyPNG::Canvas.new(1,1), 16, 16) }.to raise_error
     end
   end
   
@@ -32,21 +32,87 @@ describe OilyPNG::Operations do
     it "should compose two images without offset exactly the same way as ChunkyPNG" do
       subcanvas = ChunkyPNG::Canvas.new(3, 2, ChunkyPNG::Color.rgb(200, 255, 0))
       subject.replace!(subcanvas)
-      ChunkyPNG::Canvas.from_canvas(subject).should == reference_canvas('operations').replace(subcanvas)
+      expect(ChunkyPNG::Canvas.from_canvas(subject)).to eq(reference_canvas('operations').replace(subcanvas))
     end
 
     it "should compose two images with offset exactly the same way as ChunkyPNG" do
       subject.replace!(ChunkyPNG::Canvas.new(3, 2, ChunkyPNG::Color.rgb(200, 255, 0)), 5, 4) 
-      subject.should == oily_reference_canvas('replaced')
+      expect(subject).to eq(oily_reference_canvas('replaced'))
     end
 
     it "should return itself" do
-      subject.replace!(OilyPNG::Canvas.new(1,1)).should equal(subject)
+      expect(subject.replace!(OilyPNG::Canvas.new(1,1))).to be(subject)
     end
 
     it "should raise an exception when the pixels to compose fall outside the image" do
       # For now this raises a runtime error, but it should probably raise a ChunkyPNG::OutOfBounds error
-      lambda { subject.replace!(OilyPNG::Canvas.new(1,1), 16, 16) }.should raise_error
+      expect { subject.replace!(OilyPNG::Canvas.new(1,1), 16, 16) }.to raise_error
+    end
+  end
+
+  describe '#rotate_left!' do
+    subject { OilyPNG::Canvas.new(2, 3, [1, 2, 3, 4, 5, 6]) }
+
+    it "should rotate the pixels 90 degrees clockwise" do
+      subject.rotate_left!
+      expect(subject).to eql OilyPNG::Canvas.new(3, 2, [2, 4, 6, 1, 3, 5] )
+    end
+
+    it "should return itself" do
+      expect(subject.rotate_left!).to equal(subject)
+    end
+
+    it "should change the image dimensions" do
+      expect { subject.rotate_left! }.to change { subject.dimension }.
+          from(ChunkyPNG::Dimension('2x3')).to(ChunkyPNG::Dimension('3x2'))
+    end
+
+    it "it should rotate 180 degrees when applied twice" do
+      subject_dup = subject.dup
+      expect(subject.rotate_left!.rotate_left!).to eql subject_dup.rotate_180
+    end
+
+    it "it should rotate right when applied three times" do
+      subject_dup = subject.dup
+      expect(subject.rotate_left!.rotate_left!.rotate_left!).to eql subject_dup.rotate_right!
+    end
+
+    it "should return itself when applied four times" do
+      subject_dup = subject.dup
+      expect(subject.rotate_left!.rotate_left!.rotate_left!.rotate_left!).to eql subject_dup
+    end
+  end
+
+  describe '#rotate_right!' do
+    subject { OilyPNG::Canvas.new(2, 3, [1, 2, 3, 4, 5, 6]) }
+
+    it "should rotate the pixels 90 degrees clockwise" do
+      subject.rotate_right!
+      expect(subject).to eql OilyPNG::Canvas.new(3, 2, [5, 3, 1, 6, 4, 2] )
+    end
+
+    it "should return itself" do
+      expect(subject.rotate_right!).to equal(subject)
+    end
+
+    it "should change the image dimensions" do
+      expect { subject.rotate_right! }.to change { subject.dimension }.
+          from(ChunkyPNG::Dimension('2x3')).to(ChunkyPNG::Dimension('3x2'))
+    end
+
+    it "it should rotate 180 degrees when applied twice" do
+      subject_dup = subject.dup
+      expect(subject.rotate_right!.rotate_right!).to eql subject_dup.rotate_180
+    end
+
+    it "it should rotate left when applied three times" do
+      subject_dup = subject.dup
+      expect(subject.rotate_right!.rotate_right!.rotate_right!).to eql subject_dup.rotate_left
+    end
+
+    it "should return itself when applied four times" do
+      subject_dup = subject.dup
+      expect(subject.rotate_right!.rotate_right!.rotate_right!.rotate_right!).to eql subject_dup
     end
   end
 end

data/spec/resampling_spec.rb

@@ -6,14 +6,14 @@ describe OilyPNG::Resampling do
 
   describe '#steps' do
     it "should generate the steps from 4 to 8 as [0,0,1,1,2,2,3,3]" do
-      steps(4,8).should == [0,0,1,1,2,2,3,3]
+      expect(steps(4, 8)).to eq([0, 0, 1, 1, 2, 2, 3, 3])
     end
 
     it "should generate the steps the same as ChunkyPNG" do
       image = ChunkyPNG::Image.new(1,1)
-      steps(2,8).should == image.send(:steps,2,8)
-      steps(2,11).should == image.send(:steps,2,11)
-      steps(11,5).should == image.send(:steps,11,5)
+      expect(steps( 2,  8)).to eq(image.send(:steps, 2, 8))
+      expect(steps( 2, 11)).to eq(image.send(:steps, 2,11))
+      expect(steps(11,  5)).to eq(image.send(:steps,11, 5))
     end
   end
 
@@ -21,19 +21,19 @@ describe OilyPNG::Resampling do
     before(:all) { @reference = ChunkyPNG::Canvas.from_file(resource_file('nonsquare.png'))}
 
     it "should resample [0,1,2,3] to 4x4 properly" do
-      OilyPNG::Canvas.new(2,2,[0,1,2,3]).resample_nearest_neighbor(4,4).should == OilyPNG::Canvas.new(4,4,[0,0,1,1,0,0,1,1,2,2,3,3,2,2,3,3])
+      expect(OilyPNG::Canvas.new(2,2,[0,1,2,3]).resample_nearest_neighbor(4,4)).to eq(OilyPNG::Canvas.new(4,4,[0,0,1,1,0,0,1,1,2,2,3,3,2,2,3,3]))
     end
 
     it "should resample [0,1,2,3] to 99x45 as ChunkyPNG does" do
-      ChunkyPNG::Canvas.new(2,2,[0,1,2,3]).resample_nearest_neighbor(99,45).should == OilyPNG::Canvas.new(2,2,[0,1,2,3]).resample_nearest_neighbor(99,45)
+      expect(ChunkyPNG::Canvas.new(2,2,[0,1,2,3]).resample_nearest_neighbor(99,45)).to eq(OilyPNG::Canvas.new(2,2,[0,1,2,3]).resample_nearest_neighbor(99,45))
     end
 
     it "should resample an image to 10x20 as ChunkyPNG does" do
-      @reference.resample_nearest_neighbor(10,20).should == OilyPNG::Canvas.from_canvas(@reference).resample_nearest_neighbor(10,20)
+      expect(@reference.resample_nearest_neighbor(10,20)).to eq(OilyPNG::Canvas.from_canvas(@reference).resample_nearest_neighbor(10,20))
     end
 
     it "should resample an image to 11x19 as ChunkyPNG does" do
-      @reference.resample_nearest_neighbor(11,19).should == OilyPNG::Canvas.from_canvas(@reference).resample_nearest_neighbor(11,19)
+      expect(@reference.resample_nearest_neighbor(11,19)).to eq(OilyPNG::Canvas.from_canvas(@reference).resample_nearest_neighbor(11,19))
     end
   end
 
@@ -41,15 +41,15 @@ describe OilyPNG::Resampling do
     before(:all) { @reference = ChunkyPNG::Canvas.from_file(resource_file('nonsquare.png'))}
 
     it "should resample an image to 10x20 as ChunkyPNG does" do
-      @reference.resample_bilinear(10,20).should == OilyPNG::Canvas.from_canvas(@reference).resample_bilinear(10,20)
+      expect(@reference.resample_bilinear(10,20)).to eq(OilyPNG::Canvas.from_canvas(@reference).resample_bilinear(10,20))
     end
 
     it "should resample an image to 11x19 as ChunkyPNG does" do
-      @reference.resample_bilinear(11,19).should == OilyPNG::Canvas.from_canvas(@reference).resample_bilinear(11,19)
+      expect(@reference.resample_bilinear(11,19)).to eq(OilyPNG::Canvas.from_canvas(@reference).resample_bilinear(11,19))
     end
 
     it "should upsample an image to 88x44 as ChunkyPNG does" do
-      @reference.resample_bilinear(88,44).should == OilyPNG::Canvas.from_canvas(@reference).resample_bilinear(88,44)
+      expect(@reference.resample_bilinear(88,44)).to eq(OilyPNG::Canvas.from_canvas(@reference).resample_bilinear(88,44))
     end
 
     it "should not crash upsampling tall image" do

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: oily_png
 version: !ruby/object:Gem::Version
-  version: 1.1.2
+  version: 1.2.0
 platform: ruby
 authors:
 - Willem van Bergen
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-09-21 00:00:00.000000000 Z
+date: 2015-05-28 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: chunky_png
@@ -58,14 +58,14 @@ dependencies:
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
-        version: '2'
+        version: '3'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
-        version: '2'
+        version: '3'
 description: |2
       This Ruby C extenstion defines a module that can be included into ChunkyPNG to improve its speed.
 email: