chunky_png 1.0.0.beta2 → 1.0.0.rc1

data/lib/chunky_png/point.rb

@@ -0,0 +1,110 @@
+module ChunkyPNG
+  
+  # Factory method to create {ChunkyPNG::Point} instances.
+  # 
+  # This method tries to be as flexible as possible with regards to the given input: besides 
+  # explit coordinates, this method also accepts arrays, hashes, strings, {ChunkyPNG::Dimension}
+  # instances and anything that responds to <tt>:x</tt> and <tt>:y</tt>.
+  # 
+  # @overload Point(x, y)
+  #   @param [Integer, :to_i] x The x-coordinate
+  #   @param [Integer, :to_i] y The y-coordinate
+  #   @return [ChunkyPNG::Point] The instantiated point.
+  #
+  # @overload Point(array)
+  #   @param [Array<Integer>] array A two element array which represent the x- and y-coordinate.
+  #   @return [ChunkyPNG::Point] The instantiated point.
+  #
+  # @overload Point(hash)
+  #   @param [Hash] array A hash with the <tt>:x</tt> or <tt>'x'</tt> and <tt>:y</tt> or
+  #     <tt>'y'</tt> keys set, which will be used as coordinates.
+  #   @return [ChunkyPNG::Point] The instantiated point.
+  #
+  # @overload Point(string)
+  #   @param [String] string A string that contains the coordinates, e.g. <tt>'0, 4'</tt>,
+  #     <tt>'(0 4)'</tt>, <tt>[0,4}'</tt>, etc.
+  #   @return [ChunkyPNG::Point] The instantiated point.
+  #
+  # @raise [ChunkyPNG::ExpectationFailed] if the arguments weren't understood.
+  # @see ChunkyPNG::Point
+  def self.Point(*args)
+    case args.length
+      when 2; ChunkyPNG::Point.new(*args)
+      when 1; case source = args.first
+          when ChunkyPNG::Point; source
+          when ChunkyPNG::Dimension; ChunkyPNG::Point.new(source.width, source.height)
+          when Array; ChunkyPNG::Point.new(source[0], source[1])
+          when Hash; ChunkyPNG::Point.new(source[:x] || source['x'], source[:y] || source['y'])
+          when /^[\(\[\{]?(\d+)\s*[,]?\s*(\d+)[\)\]\}]?$/; ChunkyPNG::Point.new($1.to_i, $2.to_i)
+          else 
+            if source.respond_to?(:x) && source.respond_to?(:y)
+              ChunkyPNG::Point.new(source.x, source.y)
+            else
+              raise ChunkyPNG::ExpectationFailed, "Don't know how to construct a point from #{source.inspect}!"
+            end
+        end
+      else raise ChunkyPNG::ExpectationFailed, "Don't know how to construct a point from #{args.inspect}!"
+    end
+  end
+  
+  # Simple class that represents a point on a canvas using an x and y coordinate.
+  #
+  # This class implements some basic methods to handle comparison, the splat operator and
+  # bounds checking that make it easier to work with coordinates.
+  #
+  # @see ChunkyPNG.Point
+  class Point
+
+    # @return [Integer] The x-coordinate of the point.
+    attr_accessor :x
+
+    # @return [Integer] The y-coordinate of the point.
+    attr_accessor :y
+    
+    # Initializes a new point instance.
+    # @param [Integer, :to_i] x The x-coordinate.
+    # @param [Integer, :to_i] y The y-coordinate.
+    def initialize(x, y)
+      @x, @y = x.to_i, y.to_i
+    end
+    
+    # Checks whether 2 points are identical.
+    # @return [true, false] <tt>true</tt> iff the x and y coordinates match
+    def eql?(other)
+      other.x == x && other.y == y
+    end
+    
+    alias_method :==, :eql?
+    
+    # Comparses 2 points.
+    #
+    # It will first compare the y coordinate, and it only takes the x-coordinate into
+    # account if the y-coordinates of the points are identical. This way, an array of
+    # points will be sorted into the order in which thet would occur in the pixels
+    # array returned by {ChunkyPNG::Canvas#pixels}.
+    #
+    # @param [ChunkyPNG::Point] other The point to compare this point with.
+    # @return [-1, 0, 1] <tt>-1</tt> If this point comes before the other one, <tt>1</tt>
+    #   if after, and <tt>0</tt> if the points are identical.
+    def <=>(other)
+      ((y <=> other.y) == 0) ? x <=> other.x : y <=> other.y
+    end
+    
+    # Converts the point instance to an array.
+    # @return [Array] A 2-element array, i.e. <tt>[x, y]</tt>.
+    def to_a
+      [x, y]
+    end
+    
+    alias_method :to_ary, :to_a
+    
+    # Checks whether the point falls into a dimension
+    # @param [ChunkyPNG::Dimension, ...] dimension_like The dimension of which the bounds 
+    #   should be taken for the check.
+    # @return [true, false] <tt>true</tt> iff the x and y coordinate fall width the width 
+    #   and height of the dimension.
+    def within_bounds?(*dimension_like)
+      ChunkyPNG::Dimension(*dimension_like).include?(self)
+    end
+  end
+end

data/lib/chunky_png/vector.rb

@@ -0,0 +1,92 @@
+module ChunkyPNG
+
+  # Factory method for {ChunkyPNG::Vector} instances.
+  #
+  # @overload Vector(x0, y0, x1, y1, x2, y2, ...)
+  #   Creates a vector by parsing two subsequent values in the argument list 
+  #   as x- and y-coordinate of a point.
+  #   @return [ChunkyPNG::Vector] The instantiated vector.
+  # @overload Vector(string)
+  #   Creates a vector by parsing coordinates from the input string.
+  #   @return [ChunkyPNG::Vector] The instantiated vector.
+  # @overload Vector(pointlike, pointlike, pointlike, ...)
+  #   Creates a vector by converting every argument to a point using {ChunkyPNG.Point}.
+  #   @return [ChunkyPNG::Vector] The instantiated vector.
+  def self.Vector(*args)
+    
+    return args.first if args.length == 1 && args.first.kind_of?(ChunkyPNG::Vector)
+    
+    if args.length == 1 && args.first.respond_to?(:scan)
+      ChunkyPNG::Vector.new(ChunkyPNG::Vector.multiple_from_string(args.first)) # e.g. ['1,1 2,2 3,3']
+    else
+      ChunkyPNG::Vector.new(ChunkyPNG::Vector.multiple_from_array(args)) # e.g. [[1,1], [2,2], [3,3]] or [1,1,2,2,3,3]
+    end
+  end
+  
+  # Class that represents a vector of points, i.e. a list of {ChunkyPNG::Point} instances.
+  class Vector
+    
+    include Enumerable
+    
+    attr_reader :points
+    
+    def initialize(points = [])
+      @points = points
+    end
+    
+    def each_edge(close = true)
+      raise ChunkyPNG::ExpectationFailed, "Not enough points in this path to draw an edge!" if length < 2
+      points.each_cons(2) { |a, b| yield(a, b) }
+      yield(points.last, points.first) if close
+    end
+    
+    def edges(close = true)
+      Enumerator.new(self, :each_edge, close)
+    end
+    
+    def length
+      points.length
+    end
+    
+    def each(&block)
+      points.each(&block)
+    end
+    
+    def eql?(other)
+      other.points == points
+    end
+    
+    alias_method :==, :eql?
+    
+    def to_a
+      edges
+    end
+    
+    alias_method :to_ary, :to_a
+
+    def x_range
+      Range.new(*points.map { |p| p.x }.minmax)
+    end
+    
+    def y_range
+      Range.new(*points.map { |p| p.y }.minmax)
+    end
+    
+    def self.multiple_from_array(source)
+      return [] if source.empty?
+      if source.first.kind_of?(Numeric) || source.first =~ /^\d+$/
+        raise ChunkyPNG::ExpectationFailed, "The points array is expected to have an even number of items!" if source.length % 2 != 0
+
+        points = []
+        source.each_slice(2) { |x, y| points << ChunkyPNG::Point.new(x, y) }
+        return points
+      else
+        source.map { |p| ChunkyPNG::Point(p) }
+      end
+    end
+    
+    def self.multiple_from_string(source_str)
+      multiple_from_array(source_str.scan(/[\(\[\{]?(\d+)\s*[,x]?\s*(\d+)[\)\]\}]?/))
+    end
+  end
+end

data/spec/chunky_png/canvas/drawing_spec.rb

@@ -3,36 +3,129 @@ require 'spec_helper'
 describe ChunkyPNG::Canvas::Drawing do
   
   describe '#point' do
+    subject { ChunkyPNG::Canvas.new(1, 1, ChunkyPNG::Color.rgb(200, 150, 100)) }
+    
     it "should compose colors correctly" do
-      canvas = ChunkyPNG::Canvas.new(1, 1, ChunkyPNG::Color.rgb(200, 150, 100))
-      canvas.point(0,0, ChunkyPNG::Color.rgba(100, 150, 200, 128))
-      canvas[0,0].should == ChunkyPNG::Color.rgb(150, 150, 150)
+      subject.compose_pixel(0,0, ChunkyPNG::Color.rgba(100, 150, 200, 128))
+      subject['0,0'].should == ChunkyPNG::Color.rgb(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)
+    end
+    
+    it "should accept point-like arguments as well" do
+      lambda { subject.compose_pixel('0,0', ChunkyPNG::Color.rgba(100, 150, 200, 128)) }.should change { subject['0,0'] }
+      lambda { subject.compose_pixel({:x => 0, :y => 0}, ChunkyPNG::Color.rgba(100, 150, 200, 128)) }.should change { subject['0,0'] }
+      lambda { subject.compose_pixel(ChunkyPNG::Point.new(0, 0), ChunkyPNG::Color.rgba(100, 150, 200, 128)) } .should change { subject['0,0'] }
+    end
+    
+    it "should do nothing when the coordinates are out of bounds" do
+      subject.compose_pixel(1, -1, ChunkyPNG::Color::BLACK).should be_nil
+      lambda { subject.compose_pixel(1, -1, ChunkyPNG::Color::BLACK) }.should_not change { subject['0,0'] }
     end
   end
   
   describe '#line' do
     it "should draw lines correctly with anti-aliasing" do
-      canvas = ChunkyPNG::Canvas.new(32, 32, ChunkyPNG::Color::WHITE)
       
-      canvas.line( 0,  0, 31, 31, ChunkyPNG::Color::BLACK)
-      canvas.line( 0, 31, 31,  0, ChunkyPNG::Color::BLACK)
-      canvas.line(15, 31, 15,  0, ChunkyPNG::Color.rgba(200,   0,   0, 128))
-      canvas.line( 0, 15, 31, 15, ChunkyPNG::Color.rgba(200,   0,   0, 128))
-      canvas.line( 0, 15, 31, 31, ChunkyPNG::Color.rgba(  0, 200,   0, 128))
-      canvas.line( 0, 15, 31,  0, ChunkyPNG::Color.rgba(  0, 200,   0, 128))
-      canvas.line(15,  0, 31, 31, ChunkyPNG::Color.rgba(  0,   0, 200, 128))
-      canvas.line(15,  0,  0, 31, ChunkyPNG::Color.rgba(  0,   0, 200, 128))
+      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))
+      canvas.line( 0, 15, 30, 15, ChunkyPNG::Color.rgba(200,   0,   0, 128))
+      canvas.line(30, 30,  0, 15, ChunkyPNG::Color.rgba(  0, 200,   0, 128), false)
+      canvas.line( 0, 15, 30,  0, ChunkyPNG::Color.rgba(  0, 200,   0, 128))
+      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')
     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, ChunkyPNG::Color::BLACK)
+      canvas.pixels.should == [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, ChunkyPNG::Color::BLACK).should equal(canvas)
+    end
   end
   
   describe '#rect' do
     it "should draw a rectangle with the correct colors" do
       canvas = ChunkyPNG::Canvas.new(16, 16, ChunkyPNG::Color::WHITE)
-      canvas.rect(1, 1, 10, 10, ChunkyPNG::Color.rgb(0, 255, 0), ChunkyPNG::Color.rgba(255, 0, 0, 100))
-      canvas.rect(5, 5, 14, 14, ChunkyPNG::Color.rgb(0, 0, 255), ChunkyPNG::Color.rgba(255, 255, 0, 100))
+      canvas.rect(1, 1, 10, 10, ChunkyPNG::Color.rgba(0, 255, 0,  80), ChunkyPNG::Color.rgba(255, 0, 0, 100))
+      canvas.rect(5, 5, 14, 14, ChunkyPNG::Color.rgba(0, 0, 255, 160), ChunkyPNG::Color.rgba(255, 255, 0, 100))
       canvas.should == reference_canvas('rect')
     end
+    
+    it "should return itself to allow chaining" do
+      canvas = ChunkyPNG::Canvas.new(16, 16, ChunkyPNG::Color::WHITE)
+      canvas.rect(1, 1, 10, 10).should equal(canvas)
+    end
+    
+    it "should draw partial rectangles if the coordinates are partially out of bounds" do
+      canvas = ChunkyPNG::Canvas.new(1, 1)
+      canvas.rect(0, 0, 10, 10, ChunkyPNG::Color::BLACK, ChunkyPNG::Color::WHITE)
+      canvas[0, 0].should == ChunkyPNG::Color::BLACK
+    end
+    
+    it "should draw the rectangle fill only if the coordinates are fully out of bounds" do
+      canvas = ChunkyPNG::Canvas.new(1, 1)
+      canvas.rect(-10, -10, 10, 10, ChunkyPNG::Color::BLACK, ChunkyPNG::Color::WHITE)
+      canvas[0, 0].should == ChunkyPNG::Color::WHITE
+    end
+  end
+  
+  describe '#circle' do
+    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')
+    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')
+    end
+
+    it "should return itself to allow chaining" do
+      subject.circle(10, 10, 5).should 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')
+    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')
+    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')
+    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')
+    end
+
+    it "should return itself to allow chaining" do
+      subject.polygon('(2,2) (20,5) (5,20)').should equal(subject)
+    end
   end
 end

data/spec/chunky_png/canvas/masking_spec.rb

@@ -0,0 +1,51 @@
+require 'spec_helper'
+
+describe ChunkyPNG::Canvas::Masking do
+  
+  subject { reference_canvas('clock') }
+
+  before(:all) do
+    @theme_color      = ChunkyPNG::Color('#e10f7a')
+    @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')
+    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')
+    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
+    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')
+    end
+    
+    it "should still only have one opaque color" do
+      @mask.change_mask_color!(@new_color)
+      @mask.palette.opaque_palette.size.should == 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)
+    end
+  end
+end

data/spec/chunky_png/canvas/operations_spec.rb

@@ -1,173 +1,240 @@
 require 'spec_helper'
 
 describe ChunkyPNG::Canvas::Operations do
+  
+  subject { reference_canvas('operations') } 
+  
   describe '#crop' do
-    before { @canvas = reference_canvas('operations') }
-
     it "should crop the right pixels from the original canvas" do
-      cropped = @canvas.crop(10, 5, 4, 8)
-      cropped.should == reference_canvas('cropped')
+      subject.crop(10, 5, 4, 8).should == reference_canvas('cropped')
+    end
+    
+    it "should not return itself" do
+      subject.crop(10, 5, 4, 8).should_not equal(subject)
+    end
+    
+    it "should not adjust the currnet image" do
+      lambda { subject.crop(10, 5, 4, 8) }.should_not change(subject, :dimension)
     end
     
     it "should raise an exception when the cropped image falls outside the oiginal image" do
-      lambda { @canvas.crop(16, 16, 2, 2) }.should raise_error(ChunkyPNG::OutOfBounds)
+      lambda { subject.crop(16, 16, 2, 2) }.should 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')
+    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'))
+    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)
+    end
+    
+    it "should return itself" do
+      subject.crop!(10, 5, 4, 8).should equal(subject)
     end
   end
 
   describe '#compose' do
     it "should compose pixels correctly" do
-      canvas = reference_canvas('operations')
       subcanvas = ChunkyPNG::Canvas.new(4, 8, ChunkyPNG::Color.rgba(0, 0, 0, 75))
-      canvas.compose(subcanvas, 8, 4)
-      canvas.should == reference_canvas('composited')
+      subject.compose(subcanvas, 8, 4).should == reference_canvas('composited')
+    end
+    
+    it "should leave the original intact" do
+      subject.compose(ChunkyPNG::Canvas.new(1,1))
+      subject.should == reference_canvas('operations')
+    end
+    
+    it "should not return itself" do
+      subject.compose(ChunkyPNG::Canvas.new(1,1)).should_not equal(subject)
+    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)
+    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)
+      subject.should == reference_canvas('composited')
+    end
+    
+    it "should return itself" do
+      subject.compose!(ChunkyPNG::Canvas.new(1,1)).should 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).should == reference_canvas('clock_updated')
+      base.compose!(mask)
+      base.should == reference_canvas('clock_updated')
     end
     
     it "should raise an exception when the pixels to compose fall outside the image" do
-      lambda { reference_canvas('operations').compose(ChunkyPNG::Canvas.new(1,1), 16, 16) }.should raise_error(ChunkyPNG::OutOfBounds)
-    end
+      lambda { subject.compose!(ChunkyPNG::Canvas.new(1,1), 16, 16) }.should raise_error(ChunkyPNG::OutOfBounds)
+    end    
   end
 
   describe '#replace' do
-    before { @canvas = reference_canvas('operations') }
-
     it "should replace the correct pixels" do
       subcanvas = ChunkyPNG::Canvas.new(3, 2, ChunkyPNG::Color.rgb(200, 255, 0))
-      @canvas.replace(subcanvas, 5, 4)
-      @canvas.should == reference_canvas('replaced')
+      subject.replace(subcanvas, 5, 4).should == reference_canvas('replaced')
     end
     
-    it "should raise an exception when the pixels to replace fall outside the image" do
-      lambda { @canvas.replace(ChunkyPNG::Canvas.new(1,1), 16, 16) }.should raise_error(ChunkyPNG::OutOfBounds)
+    it "should not return itself" do
+      subject.replace(ChunkyPNG::Canvas.new(1,1)).should_not equal(subject)
     end
-  end
-  
-  describe '#change_theme_color!' do
     
-    before(:each) do
-      @theme_color = ChunkyPNG::Color.from_hex('#e10f7a')
-      @new_color   = ChunkyPNG::Color.from_hex('#ff0000')
-      @canvas      = reference_canvas('clock')
+    it "should leave the original intact" do
+      subject.replace(ChunkyPNG::Canvas.new(1,1))
+      subject.should == reference_canvas('operations')
     end
     
-    it "should change the theme color correctly" do
-      @canvas.change_theme_color!(@theme_color, @new_color)
-      @canvas.should == reference_canvas('clock_updated')
+    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)
     end
   end
   
-  describe '#extract_mask' do
-    before(:each) do
-      @mask_color = ChunkyPNG::Color.from_hex('#e10f7a')
-      @canvas     = reference_canvas('clock')
+  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)
+      subject.should == reference_canvas('replaced')
     end
     
-    it "should create the correct base and mask image" do
-      base, mask = @canvas.extract_mask(@mask_color, ChunkyPNG::Color::WHITE)
-      base.should == reference_canvas('clock_base')
-      mask.should == reference_canvas('clock_mask')
+    it "should return itself" do
+      subject.replace!(ChunkyPNG::Canvas.new(1,1)).should equal(subject)
     end
     
-    it "should create a mask image with only one opaque color" do
-      base, mask = @canvas.extract_mask(@mask_color, ChunkyPNG::Color::WHITE)
-      mask.palette.opaque_palette.size.should == 1
+    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)
     end
   end
+end
+
+describe ChunkyPNG::Canvas::Operations do
   
-  describe '#change_mask_color!' do
-    before(:each) do
-      @new_color = ChunkyPNG::Color.from_hex('#ff0000')
-      @mask      = reference_canvas('clock_mask')
+  subject { ChunkyPNG::Canvas.new(2, 3, [1, 2, 3, 4, 5, 6]) }
+
+  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])
     end
     
-    it "should replace the mask color correctly" do
-      @mask.change_mask_color!(@new_color)
-      @mask.should == reference_canvas('clock_mask_updated')
+    it "should return itself" do
+      subject.flip_horizontally!.should 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])
     end
     
-    it "should still only have one opaque color" do
-      @mask.change_mask_color!(@new_color)
-      @mask.palette.opaque_palette.size.should == 1
+    it "should not return itself" do
+      subject.flip_horizontally.should_not equal(subject)
     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)
+    it "should return a copy of itself when applied twice" do
+      subject.flip_horizontally.flip_horizontally.should == subject
     end
   end
-end
-
-describe ChunkyPNG::Canvas::Operations do
-  before { @stubbed = reference_canvas('clock_stubbed') }
-
-  describe '#flip_horizontally' do
-    it "should flip the pixels horizontally" do
-      @stubbed.flip_horizontally.should == reference_canvas('clock_flip_horizontally')
+  
+  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])
     end
     
-    it "should return itself when applied twice" do
-      @stubbed.flip_horizontally.flip_horizontally.should == @stubbed
+    it "should return itself" do
+      subject.flip_horizontally!.should equal(subject)
     end
   end
 
   describe '#flip_vertically' do
     it "should flip the pixels vertically" do
-      @stubbed.flip_vertically.should == reference_canvas('clock_flip_vertically')
+      subject.flip_vertically.should == ChunkyPNG::Canvas.new(2, 3, [2, 1, 4, 3, 6, 5])
+    end
+    
+    it "should not return itself" do
+      subject.flip_horizontally.should_not equal(subject)
     end
     
-    it "should return itself when applied twice" do
-      @stubbed.flip_vertically.flip_vertically.should == @stubbed
+    it "should return a copy of itself when applied twice" do
+      subject.flip_vertically.flip_vertically.should == subject
     end
   end
 
   describe '#rotate_left' do
     it "should rotate the pixels 90 degrees counter-clockwise" do
-      @stubbed.rotate_left.should == reference_canvas('clock_rotate_left')
+      subject.rotate_left.should == ChunkyPNG::Canvas.new(3, 2, [2, 4, 6, 1, 3, 5] )
     end
     
     it "it should rotate 180 degrees when applied twice" do
-      @stubbed.rotate_left.rotate_left.should == reference_canvas('clock_rotate_180')
+      subject.rotate_left.rotate_left.should == subject.rotate_180
     end
     
     it "it should rotate right when applied three times" do
-      @stubbed.rotate_left.rotate_left.rotate_left.should == reference_canvas('clock_rotate_right')
+      subject.rotate_left.rotate_left.rotate_left.should == subject.rotate_right
     end
     
     it "should return itself when applied four times" do
-      @stubbed.rotate_left.rotate_left.rotate_left.rotate_left.should == @stubbed
+      subject.rotate_left.rotate_left.rotate_left.rotate_left.should == subject
     end
   end
 
   describe '#rotate_right' do
     it "should rotate the pixels 90 degrees clockwise" do
-      @stubbed.rotate_right.should == reference_canvas('clock_rotate_right')
+      subject.rotate_right.should == ChunkyPNG::Canvas.new(3, 2, [5, 3, 1, 6, 4, 2] )
     end
     
     it "it should rotate 180 degrees when applied twice" do
-      @stubbed.rotate_right.rotate_right.should == reference_canvas('clock_rotate_180')
+      subject.rotate_right.rotate_right.should == subject.rotate_180
     end
     
     it "it should rotate left when applied three times" do
-      @stubbed.rotate_right.rotate_right.rotate_right.should == reference_canvas('clock_rotate_left')
+      subject.rotate_right.rotate_right.rotate_right.should == subject.rotate_left
     end
     
     it "should return itself when applied four times" do
-      @stubbed.rotate_right.rotate_right.rotate_right.rotate_right.should == @stubbed
+      subject.rotate_right.rotate_right.rotate_right.rotate_right.should == subject
     end
   end
 
   describe '#rotate_180' do
     it "should rotate the pixels 180 degrees" do
-      @stubbed.rotate_180.should == reference_canvas('clock_rotate_180')
+      subject.rotate_180.should == ChunkyPNG::Canvas.new(2, 3, [6, 5, 4, 3, 2, 1])
+    end
+    
+    it "should return not itself" do
+      subject.rotate_180.should_not equal(subject)
+    end
+    
+    it "should return a copy of itself when applied twice" do
+      subject.rotate_180.rotate_180.should == 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])
     end
     
-    it "should return itself when applied twice" do
-      @stubbed.rotate_180.rotate_180.should == @stubbed
+    it "should return itself" do
+      subject.rotate_180!.should equal(subject)
     end
   end
 end