chunky_png 1.0.0.beta2 → 1.0.0.rc1

data/spec/chunky_png/canvas/resampling_spec.rb

@@ -0,0 +1,31 @@
+require 'spec_helper'
+
+describe ChunkyPNG::Canvas::Resampling do
+
+  subject { reference_canvas('clock') } 
+
+  describe '#resample_nearest_neighbor' do
+    
+    it "should downscale from 2x2 to 1x1 correctly" do
+      canvas = ChunkyPNG::Canvas.new(2, 2, [1, 2, 3, 4])
+      canvas.resample_nearest_neighbor(1, 1).should == ChunkyPNG::Canvas.new(1, 1, [1])
+    end
+    
+    it "should downscale from 2x2 to 4x4 correctly" do
+      canvas = ChunkyPNG::Canvas.new(2, 2, [1, 2, 3, 4])
+      canvas.resample_nearest_neighbor(4, 4).should == ChunkyPNG::Canvas.new(4, 4, [1,1,1,2,1,1,1,2,1,1,1,2,3,3,3,4])
+    end
+    
+    it "should upscale both axis of the image" do
+      subject.resample_nearest_neighbor(45, 45).should == reference_canvas('clock_nn_xup_yup')
+    end
+    
+    it "should downscale both axis of the image" do
+      subject.resample_nearest_neighbor(12, 12).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).should == reference_canvas('clock_nn_xdown_yup')
+    end
+  end
+end

data/spec/chunky_png/canvas/stream_exporting_spec.rb

@@ -0,0 +1,20 @@
+require 'spec_helper'
+
+describe ChunkyPNG::Canvas do
+  
+  describe '#to_rgba_stream' do
+    before { File.open(resource_file('pixelstream.rgba'), 'rb') { |f| @reference_data = f.read } }
+    
+    it "should load an image correctly from a datastream" do
+      reference_canvas('pixelstream_reference').to_rgba_stream.should == @reference_data
+    end
+  end
+
+  describe '#to_rgb_stream' do
+    before { File.open(resource_file('pixelstream.rgb'), 'rb') { |f| @reference_data = f.read } }
+    
+    it "should load an image correctly from a datastream" do
+      reference_canvas('pixelstream_reference').to_rgb_stream.should == @reference_data
+    end
+  end
+end

data/spec/chunky_png/canvas/stream_importing_spec.rb

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

data/spec/chunky_png/canvas_spec.rb

@@ -2,37 +2,150 @@ require 'spec_helper'
 
 describe ChunkyPNG::Canvas do
 
-  describe '.from_rgb_stream' do
-    it "should load an image correctly from a datastream" do
-      File.open(resource_file('pixelstream.rgb')) do |stream|
-        matrix = ChunkyPNG::Canvas.from_rgb_stream(240, 180, stream)
-        matrix.should == reference_canvas('pixelstream_reference')
-      end
+  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 '#dimension' do
+    it "should return the dimensions as a Dimension instance" do
+      subject.dimension.should == ChunkyPNG::Dimension('1x1')
+    end
+  end
+  
+  describe '#area' do
+    it "should return the dimensions as two-item array" do
+      subject.area.should == ChunkyPNG::Dimension('1x1').area
     end
   end
 
-  describe '.from_rgba_stream' do
-    it "should load an image correctly from a datastream" do
-      File.open(resource_file('pixelstream.rgba')) do |stream|
-        matrix = ChunkyPNG::Canvas.from_rgba_stream(240, 180, stream)
-        matrix.should == reference_canvas('pixelstream_reference')
-      end
+  describe '#include?' do
+    it "should return true if the coordinates are within bounds, false otherwise" do
+      subject.include_xy?( 0,  0).should be_true
+      
+      subject.include_xy?(-1,  0).should be_false
+      subject.include_xy?( 1,  0).should be_false
+      subject.include_xy?( 0, -1).should be_false
+      subject.include_xy?( 0,  1).should be_false
+      subject.include_xy?(-1, -1).should be_false
+      subject.include_xy?(-1,  1).should be_false
+      subject.include_xy?( 1, -1).should be_false
+      subject.include_xy?( 1,  1).should be_false
+    end
+    
+    it "should accept strings, arrays, hashes and points as well" do
+      subject.should     include('0, 0')
+      subject.should_not include('0, 1')
+      subject.should     include([0, 0])
+      subject.should_not include([0, 1])
+      subject.should     include(:y => 0, :x => 0)
+      subject.should_not include(:y => 1, :x => 0)
+      subject.should     include(ChunkyPNG::Point.new(0, 0))
+      subject.should_not include(ChunkyPNG::Point.new(0, 1))
     end
   end
   
-  describe '#to_rgba_stream' do
-    before { File.open(resource_file('pixelstream.rgba'), 'rb') { |f| @reference_data = f.read } }
+  describe '#include_x?' do
+    it "should return true if the x-coordinate is within bounds, false otherwise" do
+      subject.include_x?( 0).should be_true
+      subject.include_x?(-1).should be_false
+      subject.include_x?( 1).should be_false
+    end
+  end
+  
+  describe '#include_y?' do
+    it "should return true if the y-coordinate is within bounds, false otherwise" do
+      subject.include_y?( 0).should be_true
+      subject.include_y?(-1).should be_false
+      subject.include_y?( 1).should be_false
+    end
+  end
+  
+  describe '#assert_xy!' do
+    it "should not raise an exception if the coordinates are within bounds" do
+      subject.should_receive(:include_xy?).with(0, 0).and_return(true)
+      lambda { subject.send(:assert_xy!, 0, 0) }.should_not raise_error
+    end
     
-    it "should load an image correctly from a datastream" do
-      reference_canvas('pixelstream_reference').to_rgba_stream.should == @reference_data
+    it "should raise an exception if the coordinates are out of bounds bounds" do
+      subject.should_receive(:include_xy?).with(0, -1).and_return(false)
+      lambda { subject.send(:assert_xy!, 0, -1) }.should raise_error(ChunkyPNG::OutOfBounds)
     end
   end
-
-  describe '#to_rgb_stream' do
-    before { File.open(resource_file('pixelstream.rgb'), 'rb') { |f| @reference_data = f.read } }
+  
+  describe '#assert_x!' do
+    it "should not raise an exception if the x-coordinate is within bounds" do
+      subject.should_receive(:include_x?).with(0).and_return(true)
+      lambda { subject.send(:assert_x!, 0) }.should_not raise_error
+    end
+    
+    it "should raise an exception if the x-coordinate is out of bounds bounds" do
+      subject.should_receive(:include_y?).with(-1).and_return(false)
+      lambda { subject.send(:assert_y!, -1) }.should raise_error(ChunkyPNG::OutOfBounds)
+    end
+  end
+  
+  describe '#[]' do
+    it "should return the pixel value if the coordinates are within bounds" do
+      subject[0, 0].should == ChunkyPNG::Color::WHITE
+    end
+    
+    it "should assert the coordinates to be within bounds" do
+      subject.should_receive(:assert_xy!).with(0, 0)
+      subject[0, 0]
+    end
+  end
+  
+  describe '#get_pixel' do
+    it "should return the pixel value if the coordinates are within bounds" do
+      subject.get_pixel(0, 0).should == ChunkyPNG::Color::WHITE
+    end
     
-    it "should load an image correctly from a datastream" do
-      reference_canvas('pixelstream_reference').to_rgb_stream.should == @reference_data
+    it "should not assert nor check the coordinates" do
+      subject.should_not_receive(:assert_xy!)
+      subject.should_not_receive(:include_xy?)
+      subject.get_pixel(0, 0)
+    end
+  end
+  
+  describe '#[]=' do
+    it "should change the pixel's color value" do
+      lambda { subject[0, 0] = ChunkyPNG::Color::BLACK }.should change { subject[0, 0] }.from(ChunkyPNG::Color::WHITE).to(ChunkyPNG::Color::BLACK)
+    end
+    
+    it "should assert the bounds of the image" do
+      subject.should_receive(:assert_xy!).with(0, 0)
+      subject[0, 0] = ChunkyPNG::Color::BLACK
+    end
+  end
+  
+  describe 'set_pixel' do
+    it "should change the pixel's color value" do
+      lambda { subject.set_pixel(0, 0, ChunkyPNG::Color::BLACK) }.should 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
+      subject.should_not_receive(:assert_xy!)
+      subject.should_not_receive(:include_xy?)
+      subject.set_pixel(0, 0, ChunkyPNG::Color::BLACK)
+    end
+  end
+  
+  describe '#set_pixel_if_within_bounds' do
+    it "should change the pixel's color value" do
+      lambda { subject.set_pixel_if_within_bounds(0, 0, ChunkyPNG::Color::BLACK) }.should change { subject[0, 0] }.from(ChunkyPNG::Color::WHITE).to(ChunkyPNG::Color::BLACK)
+    end
+
+    it "should not assert, but only check the coordinates" do
+      subject.should_not_receive(:assert_xy!)
+      subject.should_receive(:include_xy?).with(0, 0)
+      subject.set_pixel_if_within_bounds(0, 0, ChunkyPNG::Color::BLACK)
+    end
+
+    it "should do nothing if the coordinates are out of bounds" do
+      subject.set_pixel_if_within_bounds(-1, 1, ChunkyPNG::Color::BLACK).should be_nil
+      subject[0, 0].should == ChunkyPNG::Color::WHITE
     end
   end
   
@@ -50,7 +163,7 @@ describe ChunkyPNG::Canvas do
       data.should == [65535, 268500991, 536936447, 805371903, 1073807359, 1342242815, 1610678271, 1879113727, 2147549183, 2415984639, 2684420095, 2952855551, 3221291007, 3489726463, 3758161919, 4026597375]
     end
   end
-
+  
   describe '#column' do
     before { @canvas = reference_canvas('operations') }
 
@@ -65,4 +178,20 @@ describe ChunkyPNG::Canvas do
       data.should == [65535, 1114111, 2162687, 3211263, 4259839, 5308415, 6356991, 7405567, 8454143, 9502719, 10551295, 11599871, 12648447, 13697023, 14745599, 15794175]
     end
   end
+  
+  describe '#replace_canvas' do
+    it "should change the dimension of the canvas" do
+      lambda { subject.send(:replace_canvas!, 2, 2, [1,2,3,4]) }.should change(subject, :dimension).
+          from(ChunkyPNG::Dimension('1x1')).to(ChunkyPNG::Dimension('2x2'))
+    end
+    
+    it "should change the pixel array" do
+      lambda { subject.send(:replace_canvas!, 2, 2, [1,2,3,4]) }.should change(subject, :pixels).
+          from([ChunkyPNG::Color('white')]).to([1,2,3,4])
+    end
+    
+    it "should return itself" do
+      subject.send(:replace_canvas!, 2, 2, [1,2,3,4]).should equal(subject)
+    end
+  end
 end

data/spec/chunky_png/color_spec.rb

@@ -10,6 +10,27 @@ describe ChunkyPNG::Color do
     @non_opaque        = 0x0a649664
     @fully_transparent = 0x0a649600
   end
+  
+  it "should interpret 4 arguments as RGBA values" do
+    ChunkyPNG::Color(1, 2, 3, 4).should == ChunkyPNG::Color.rgba(1, 2, 3, 4)
+  end
+  
+  it "should interpret 3 arguments as RGBA values" do
+    ChunkyPNG::Color(1, 2, 3).should == ChunkyPNG::Color.rgb(1, 2, 3)
+  end
+  
+  it "should interpret a hex string correctly" do
+    ChunkyPNG::Color('0x0a649664').should == ChunkyPNG::Color.from_hex('#0a649664')
+    ChunkyPNG::Color('0x0a649664', 0xff).should == ChunkyPNG::Color.from_hex('#0a6496', 0xff)
+  end
+  
+  it "should interpret a color name correctly" do
+    ChunkyPNG::Color(:spring_green).should == 0x00ff7fff
+    ChunkyPNG::Color('spring green').should == 0x00ff7fff
+    ChunkyPNG::Color('spring green @ 0.6666').should == 0x00ff7faa
+    ChunkyPNG::Color('spring green', 0xaa).should == 0x00ff7faa
+    ChunkyPNG::Color('spring green @ 0.6666', 0xff).should == 0x00ff7fff
+  end
 
   describe '#pixel_bytesize' do
     it "should return the normal amount of bytes with a bit depth of 8" do
@@ -59,6 +80,38 @@ describe ChunkyPNG::Color do
       from_hex('#0a6496').should    == @opaque
       from_hex('0x0a6496').should   == @opaque
     end
+    
+    it "should allow setting opacity explicitely" do
+      from_hex('0x0a6496', 0x64).should == @non_opaque
+      from_hex('#0a6496', 0x64).should  == @non_opaque
+    end
+  end
+  
+  describe '#html_color' do
+    it "should find the correct color value" do
+      html_color(:springgreen).should   == 0x00ff7fff
+      html_color(:spring_green).should  == 0x00ff7fff
+      html_color('springgreen').should  == 0x00ff7fff
+      html_color('spring green').should == 0x00ff7fff
+      html_color('SpringGreen').should  == 0x00ff7fff
+      html_color('SPRING_GREEN').should == 0x00ff7fff
+    end
+    
+    it "should set the opacity level explicitely" do
+      html_color(:springgreen, 0xff).should == 0x00ff7fff
+      html_color(:springgreen, 0xaa).should == 0x00ff7faa
+      html_color(:springgreen, 0x00).should == 0x00ff7f00
+    end
+    
+    it "should set opacity levels from the color name" do
+      html_color('Spring green @ 1.0').should   == 0x00ff7fff
+      html_color('Spring green @ 0.666').should == 0x00ff7faa
+      html_color('Spring green @ 0.0').should   == 0x00ff7f00
+    end
+    
+    it "should raise for an unkown color name" do
+      lambda { html_color(:nonsense) }.should raise_error(ChunkyPNG::Exception)
+    end
   end
   
   describe '#opaque?' do

data/spec/chunky_png/dimension_spec.rb

@@ -0,0 +1,43 @@
+require 'spec_helper'
+
+describe ChunkyPNG::Dimension do
+  subject { ChunkyPNG::Dimension.new(2, 3) }
+  
+  it { should respond_to(:width) }
+  it { should respond_to(:height) }
+  
+  describe '#area' do
+    it "should calculate the area correctly" do
+      subject.area.should == 6
+    end
+  end
+end
+
+describe 'ChunkyPNG.Dimension' do
+  subject { ChunkyPNG::Dimension.new(1, 2) }
+  
+  it "should create a point 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
+    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
+    [
+      ChunkyPNG::Dimension('1,2'),
+      ChunkyPNG::Dimension('1   2'),
+      ChunkyPNG::Dimension('(1 , 2)'),
+      ChunkyPNG::Dimension("{1x2}"),
+      ChunkyPNG::Dimension("[1\t2}"),
+    ].all? { |point| point == 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)
+  end
+end

data/spec/chunky_png/point_spec.rb

@@ -0,0 +1,71 @@
+require 'spec_helper'
+
+describe ChunkyPNG::Point do
+  
+  subject { ChunkyPNG::Point.new(1, 2) }
+  
+  it { should respond_to(:x) }
+  it { should respond_to(:y) }
+  
+  describe '#within_bounds?' do
+    it { should     be_within_bounds(2, 3)  }
+    it { should_not be_within_bounds('1x3') }
+    it { should_not be_within_bounds(2, 2) }
+    it { should_not be_within_bounds('[1 2]') }
+  end
+  
+  describe '#<=>' do
+    it "should return 0 if the coordinates are identical" do
+      (subject <=> ChunkyPNG::Point.new(1, 2)).should == 0
+    end
+
+    it "should return -1 if the y coordinate is smaller than the other one" do
+      (subject <=> ChunkyPNG::Point.new(1, 3)).should == -1
+      (subject <=> ChunkyPNG::Point.new(0, 3)).should == -1 # x doesn't matter
+      (subject <=> ChunkyPNG::Point.new(2, 3)).should == -1 # x doesn't matter
+    end
+
+    it "should return 1 if the y coordinate is larger than the other one" do
+      (subject <=> ChunkyPNG::Point.new(1, 0)).should == 1
+      (subject <=> ChunkyPNG::Point.new(0, 0)).should == 1 # x doesn't matter
+      (subject <=> ChunkyPNG::Point.new(2, 0)).should == 1 # x doesn't matter
+    end
+
+    it "should return -1 if the x coordinate is smaller and y is the same" do
+      (subject <=> ChunkyPNG::Point.new(2, 2)).should == -1
+    end
+
+    it "should return 1 if the x coordinate is larger and y is the same" do
+      (subject <=> ChunkyPNG::Point.new(0, 2)).should == 1
+    end
+  end
+end
+
+describe 'ChunkyPNG.Point' do
+  subject { ChunkyPNG::Point.new(1, 2) }
+  
+  it "should create a point from a 2-item array" do
+    ChunkyPNG::Point([1, 2]).should     == subject
+    ChunkyPNG::Point(['1', '2']).should == subject
+  end
+  
+  it "should create a point from a hash with x and y keys" do
+    ChunkyPNG::Point(:x => 1, :y => 2).should       == subject
+    ChunkyPNG::Point('x' => '1', 'y' => '2').should == subject
+  end
+  
+  it "should create a point from a point-like string" do
+    [
+      ChunkyPNG::Point('1,2'),
+      ChunkyPNG::Point('1   2'),
+      ChunkyPNG::Point('(1 , 2)'),
+      ChunkyPNG::Point("{1,\t2}"),
+      ChunkyPNG::Point("[1 2}"),
+    ].all? { |point| point == 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)
+  end
+end