chunky_png 1.0.0.rc1 → 1.0.0.rc2

data/spec/chunky_png/canvas/operations_spec.rb

@@ -182,6 +182,14 @@ describe ChunkyPNG::Canvas::Operations do
       subject.rotate_left.should == ChunkyPNG::Canvas.new(3, 2, [2, 4, 6, 1, 3, 5] )
     end
     
+    it "should not return itself" do
+      subject.rotate_left.should_not equal(subject)
+    end
+    
+    it "should not change the image dimensions" do
+      lambda { subject.rotate_left }.should_not change(subject, :dimension)
+    end
+    
     it "it should rotate 180 degrees when applied twice" do
       subject.rotate_left.rotate_left.should == subject.rotate_180
     end
@@ -194,12 +202,35 @@ describe ChunkyPNG::Canvas::Operations do
       subject.rotate_left.rotate_left.rotate_left.rotate_left.should == 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] )
+    end
+    
+    it "should return itself" do
+      subject.rotate_left!.should 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'))
+    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] )
     end
     
+    it "should not return itself" do
+      subject.rotate_right.should_not equal(subject)
+    end
+    
+    it "should not change the image dimensions" do
+      lambda { subject.rotate_right }.should_not change(subject, :dimension)
+    end
+    
     it "it should rotate 180 degrees when applied twice" do
       subject.rotate_right.rotate_right.should == subject.rotate_180
     end
@@ -212,6 +243,21 @@ describe ChunkyPNG::Canvas::Operations do
       subject.rotate_right.rotate_right.rotate_right.rotate_right.should == 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] )
+    end
+    
+    it "should return itself" do
+      subject.rotate_right!.should 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'))
+    end
+  end
 
   describe '#rotate_180' do
     it "should rotate the pixels 180 degrees" do

data/spec/chunky_png/canvas/resampling_spec.rb

@@ -27,5 +27,38 @@ describe ChunkyPNG::Canvas::Resampling do
     it "should downscale the x-axis and upscale the y-axis of the image" do
       subject.resample_nearest_neighbor(20, 50).should == reference_canvas('clock_nn_xdown_yup')
     end
+    
+    it "should not return itself" do
+      subject.resample_nearest_neighbor(1, 1).should_not equal(subject)
+    end
+    
+    it "should not change the original image's dimensions" do
+      lambda { subject.resample_nearest_neighbor(1, 1) }.should_not change(subject, :dimension)
+    end
+  end
+  
+  describe '#resample_nearest_neighbor!' do
+    it "should upscale both axis of the image" do
+      subject.resample_nearest_neighbor!(45, 45)
+      subject.should == reference_canvas('clock_nn_xup_yup')
+    end
+    
+    it "should downscale both axis of the image" do
+      subject.resample_nearest_neighbor!(12, 12)
+      subject.should == 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)
+      subject.should == reference_canvas('clock_nn_xdown_yup')
+    end
+    
+    it "should return itself" do
+      subject.resample_nearest_neighbor!(1, 1).should equal(subject)
+    end
+    
+    it "should change the original image's dimensions" do
+      lambda { subject.resample_nearest_neighbor!(1, 1) }.should change(subject, :dimension).to(ChunkyPNG::Dimension('1x1'))
+    end
   end
 end

data/spec/chunky_png/dimension_spec.rb

@@ -16,17 +16,17 @@ end
 describe 'ChunkyPNG.Dimension' do
   subject { ChunkyPNG::Dimension.new(1, 2) }
   
-  it "should create a point from a 2-item array" do
+  it "should create a dimension from a 2-item array" do
     ChunkyPNG::Dimension([1, 2]).should     == subject
     ChunkyPNG::Dimension(['1', '2']).should == subject
   end
   
-  it "should create a point from a hash with x and y keys" do
+  it "should create a dimension from a hash with x and y keys" do
     ChunkyPNG::Dimension(:width => 1, :height => 2).should       == subject
     ChunkyPNG::Dimension('width' => '1', 'height' => '2').should == subject
   end
   
-  it "should create a point from a point-like string" do
+  it "should create a dimension from a point-like string" do
     [
       ChunkyPNG::Dimension('1,2'),
       ChunkyPNG::Dimension('1   2'),
@@ -36,8 +36,13 @@ describe 'ChunkyPNG.Dimension' do
     ].all? { |point| point == subject }
   end
   
+  it "should create a dimension from an object that responds to width and height" do
+    mock_object = mock('Some object with width and height', :width => 1, :height => 2)
+    ChunkyPNG::Dimension(mock_object).should == subject
+  end
+  
   it "should raise an exception if the input is not understood" do
-    lambda { ChunkyPNG::Dimension(Object.new) }.should raise_error(ChunkyPNG::ExpectationFailed)
-    lambda { ChunkyPNG::Dimension(1, 2, 3) }.should raise_error(ChunkyPNG::ExpectationFailed)
+    lambda { ChunkyPNG::Dimension(Object.new) }.should raise_error(ArgumentError)
+    lambda { ChunkyPNG::Dimension(1, 2, 3) }.should raise_error(ArgumentError)
   end
 end

data/spec/chunky_png/point_spec.rb

@@ -64,8 +64,13 @@ describe 'ChunkyPNG.Point' do
     ].all? { |point| point == subject }
   end
   
+  it "should create a point from an object that responds to x and y" do
+    mock_object = mock('Some object with x and y', :x => 1, :y => 2)
+    ChunkyPNG::Point(mock_object).should == subject
+  end
+  
   it "should raise an exception if the input is not understood" do
-    lambda { ChunkyPNG::Point(Object.new) }.should raise_error(ChunkyPNG::ExpectationFailed)
-    lambda { ChunkyPNG::Point(1, 2, 3) }.should raise_error(ChunkyPNG::ExpectationFailed)
+    lambda { ChunkyPNG::Point(Object.new) }.should raise_error(ArgumentError)
+    lambda { ChunkyPNG::Point(1, 2, 3) }.should raise_error(ArgumentError)
   end
 end

data/spec/chunky_png/vector_spec.rb

@@ -1,39 +1,85 @@
 require 'spec_helper'
 
 describe ChunkyPNG::Vector do
-  subject { ChunkyPNG::Vector.new([ChunkyPNG::Point.new(2, 4), ChunkyPNG::Point.new(1, 2), ChunkyPNG::Point.new(3, 6)]) }
+  subject { ChunkyPNG::Vector.new([ChunkyPNG::Point.new(2, 5), ChunkyPNG::Point.new(1, 3), ChunkyPNG::Point.new(4, 6)]) }
 
   it { should respond_to(:points) }
   it { should have(3).items }
 
   describe '#x_range' do
     it "should get the right range of x values" do
-      subject.x_range.should == (1..3)
+      subject.x_range.should == (1..4)
+    end
+    
+    it "should find the minimum x-coordinate" do
+      subject.min_x.should == 1
+    end
+    
+    it "should find the maximum x-coordinate" do
+      subject.max_x.should == 4
+    end
+    
+    it "should calculate the width correctly" do
+      subject.width.should == 4
     end
   end
 
   describe '#y_range' do
     it "should get the right range of y values" do
-      subject.y_range.should == (2..6)
+      subject.y_range.should == (3..6)
+    end
+    
+    it "should find the minimum x-coordinate" do
+      subject.min_y.should == 3
+    end
+    
+    it "should find the maximum x-coordinate" do
+      subject.max_y.should == 6
+    end
+    
+    it "should calculate the height correctly" do
+      subject.height.should == 4
+    end
+  end
+  
+  describe '#offset' do
+    it "should return a ChunkyPNG::Point" do
+      subject.offset.should be_kind_of(ChunkyPNG::Point)
+    end
+    
+    it "should use the mininum x and y coordinates as values for the point" do
+      subject.offset.x.should == subject.min_x
+      subject.offset.y.should == subject.min_y
+    end
+  end
+
+  describe '#dimension' do
+    it "should return a ChunkyPNG::Dimension" do
+      subject.dimension.should be_kind_of(ChunkyPNG::Dimension)
+    end
+    
+    it "should use the width and height of the vector for the dimension" do
+      subject.dimension.width.should == subject.width
+      subject.dimension.height.should == subject.height
     end
   end
 
   describe '#edges' do
     it "should get three edges when closing the path" do
-      subject.edges(true).to_a.should == [[ChunkyPNG::Point.new(2, 4), ChunkyPNG::Point.new(1, 2)],
-                                          [ChunkyPNG::Point.new(1, 2), ChunkyPNG::Point.new(3, 6)],
-                                          [ChunkyPNG::Point.new(3, 6), ChunkyPNG::Point.new(2, 4)]]
+      subject.edges(true).to_a.should == [[ChunkyPNG::Point.new(2, 5), ChunkyPNG::Point.new(1, 3)],
+                                          [ChunkyPNG::Point.new(1, 3), ChunkyPNG::Point.new(4, 6)],
+                                          [ChunkyPNG::Point.new(4, 6), ChunkyPNG::Point.new(2, 5)]]
     end
 
     it "should get two edges when not closing the path" do
-      subject.edges(false).to_a.should == [[ChunkyPNG::Point.new(2, 4), ChunkyPNG::Point.new(1, 2)],
-                                           [ChunkyPNG::Point.new(1, 2), ChunkyPNG::Point.new(3, 6)]]
+      subject.edges(false).to_a.should == [[ChunkyPNG::Point.new(2, 5), ChunkyPNG::Point.new(1, 3)],
+                                           [ChunkyPNG::Point.new(1, 3), ChunkyPNG::Point.new(4, 6)]]
     end
   end
 end
 
 describe 'ChunkyPNG.Vector' do
-  subject { ChunkyPNG::Vector.new([ChunkyPNG::Point.new(2, 4), ChunkyPNG::Point.new(1, 2), ChunkyPNG::Point.new(3, 6)]) }
+  let(:example) { ChunkyPNG::Vector.new([ChunkyPNG::Point.new(2, 4), ChunkyPNG::Point.new(1, 2), ChunkyPNG::Point.new(3, 6)]) }
   
   it "should return an empty vector when given an empty array" do
     ChunkyPNG::Vector().should == ChunkyPNG::Vector.new([])
@@ -41,18 +87,18 @@ describe 'ChunkyPNG.Vector' do
   end
 
   it "should raise an error when an odd number of numerics is given" do
-    lambda { ChunkyPNG::Vector(1, 2, 3) }.should raise_error(ChunkyPNG::ExpectationFailed)
+    lambda { ChunkyPNG::Vector(1, 2, 3) }.should raise_error(ArgumentError)
   end
 
   it "should create a vector from a string" do
-    ChunkyPNG::Vector('(2,4) (1,2) (3,6)').should == subject
+    ChunkyPNG::Vector('(2,4) (1,2) (3,6)').should == example
   end
   
   it "should create a vector from a flat array" do
-    ChunkyPNG::Vector(2,4,1,2,3,6).should == subject
+    ChunkyPNG::Vector(2,4,1,2,3,6).should == example
   end
 
   it "should create a vector from a nested array" do
-    ChunkyPNG::Vector('(2,4)', [1, 2], :x => 3, :y => 6).should == subject
+    ChunkyPNG::Vector('(2,4)', [1, 2], :x => 3, :y => 6).should == example
   end
 end

metadata

@@ -6,8 +6,8 @@ version: !ruby/object:Gem::Version
   - 1
   - 0
   - 0
-  - rc1
-  version: 1.0.0.rc1
+  - rc2
+  version: 1.0.0.rc2
 platform: ruby
 authors: 
 - Willem van Bergen
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-02-24 00:00:00 -05:00
+date: 2011-03-02 00:00:00 -05:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency