gosu_enhanced 0.2.0 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: c5dd0948ca7db7ec8a520b70f29b267aa8883eaf
-  data.tar.gz: 8a160117c73e5d9d67bc751b63ad44784bdda3f3
+  metadata.gz: c84be3918a088b23a001df84ce7eed6b012a9373
+  data.tar.gz: df2ce42f9f3dd63917891aa15003421adf601a50
 SHA512:
-  metadata.gz: e13b5c1e84a17fb7a7c6323e13cf2d957e37a495245d3025c2bf24a6bc1dae1469163ce79e6db3081ec47da64efec9adb8834d35bc8c305233dde60b74019f64
-  data.tar.gz: bc0fe6bc7545d2cfe6efe5a567b7aabd0adda888bf4a5b09dbdaf74581d793b7d944117ad5444f278cdc2adb2ea040752d62d91100d1dcb2e0b4eb92417d124a
+  metadata.gz: 520b635d9e2c6aaa5416c9549beb980a5f988bf126f292323a3ab1a28e64e736cb9161d78350b01a282ea174264f3f0d295010ab2e47b5de7208276c5473f1f5
+  data.tar.gz: 801a931e4341016bc16cbc57b110a41c5c7ce0ced10c097832b1492dbe8905271dc0f05d50899da33ca104ab90cca79543a5cd6de508c34faeb32106f326751f

data/.gitignore

@@ -19,3 +19,5 @@ tmp
 *.o
 *.a
 mkmf.log
+.rubocop.yml
+

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    gosu_enhanced (0.2.0)
+    gosu_enhanced (0.3.0)
       gosu (~> 0.7)
 
 GEM

data/lib/gosu_enhanced.rb

@@ -1,6 +1,6 @@
 require 'gosu'
 
-require "gosu_enhanced/version"
+require 'gosu_enhanced/version'
 
 require 'gosu_enhanced/point'
 require 'gosu_enhanced/size'

data/lib/gosu_enhanced/enhanced.rb

@@ -18,23 +18,22 @@ module Gosu
 
   # Add a measure to return both width and height for a text and a way
   # to centre a text in a rectangle
-  
   class Font
     include GosuEnhanced
 
     def measure( text )
       Size.new( text_width( text, 1 ), height )
     end
-    
+
     def centred_in( text, rect )
       size = measure( text )
-      
-      Point.new( 
-        (rect.width - size.width) / 2, 
-        (rect.height - size.height) / 2 
+
+      Point.new(
+        (rect.width - size.width) / 2,
+        (rect.height - size.height) / 2
       )
     end
 
     alias_method :centered_in, :centred_in
-  end  
+  end
 end

data/lib/gosu_enhanced/point.rb

@@ -4,17 +4,22 @@ module GosuEnhanced
     def offset( by_x, by_y = nil )
       if by_x.respond_to? :x
         Point.new( x + by_x.x, y + by_x.y )
+      elsif by_x.respond_to? :width
+        Point.new( x + by_x.width, y + by_x.height )
       else
         Point.new( x + by_x, y + by_y )
       end
     end
 
     # Negative co-ordinates are allowed.
-    
+
     def move_by!( by_x, by_y = nil )
       if by_x.respond_to? :x
         self.x += by_x.x
         self.y += by_x.y
+      elsif by_x.respond_to? :width
+        self.x += by_x.width
+        self.y += by_x.height
       else
         self.x += by_x
         self.y += by_y

data/lib/gosu_enhanced/region.rb

@@ -5,40 +5,41 @@ module GosuEnhanced
   # Most functions are delegated to the constituent Point and Size
   class Region
     extend Forwardable
-    
+
     def_delegators :@position, :move_by!, :move_to!, :x, :y
     def_delegators :@size, :inflate!, :deflate!, :width, :height
-    
+
     attr_reader :position, :size
-    
+
     def initialize( pos, size )
       @position, @size = pos.dup, size.dup
     end
-    
+
     def contains?( col, row = nil )
       if col.respond_to? :x
-        col.x.between?( left, left + width - 1 ) && 
+        col.x.between?( left, left + width - 1 ) &&
         col.y.between?( top, top + height - 1 )
       else
-        col.between?( left, left + width - 1 ) && 
+        col.between?( left, left + width - 1 ) &&
         row.between?( top, top + height - 1 )
-      end        
+      end
     end
-    
+
     def top
       position.y
     end
-    
+
     def left
       position.x
     end
-  
+
+    # It is necessary to override dup to produce an actual duplicate.
     def dup
       Region.new( position.dup, size.dup )
     end
-    
-    def draw( surface, z, colour )
-      surface.draw_rectangle( position, size, z, colour )
+
+    def draw( surface, z_order, colour )
+      surface.draw_rectangle( position, size, z_order, colour )
     end
   end
 end

data/lib/gosu_enhanced/size.rb

@@ -2,23 +2,23 @@ module GosuEnhanced
   # Hold a 2-dimensional size and allow for inflation / deflation
   class Size
     attr_reader :width, :height
-    
+
     # Neither dimension can be negative, since that doesn't make sense.
     # The values are checked on inflation / deflation.
-    
+
     def initialize( w, h )
       @width, @height = w, h
       validate( 0, 0 )
     end
-    
+
     def inflate( by_w, by_h = nil )
       if by_w.respond_to? :width
         validate( by_w.width, by_w.height )
-        
+
         Size.new( width + by_w.width, height + by_w.height )
       else
         validate( by_w, by_h )
-        
+
         Size.new( width + by_w, height + by_h )
       end
     end
@@ -34,12 +34,12 @@ module GosuEnhanced
     def inflate!( by_w, by_h = nil )
       if by_w.respond_to? :width
         validate( by_w.width, by_w.height )
-        
+
         @width  += by_w.width
         @height += by_w.height
       else
         validate( by_w, by_h )
-        
+
         @width  += by_w
         @height += by_h
       end
@@ -52,14 +52,15 @@ module GosuEnhanced
         inflate!( -by_w, -by_h )
       end
     end
-    
+
     def ==( other )
       width == other.width && height == other.height
     end
+
     private
-    
+
     def validate( by_w, by_h )
-      fail "Cannot make size negative" if width + by_w < 0 || height + by_h < 0      
+      fail 'Cannot make size negative' if width + by_w < 0 || height + by_h < 0
     end
-  end  
+  end
 end

data/lib/gosu_enhanced/version.rb

@@ -1,3 +1,3 @@
 module GosuEnhanced
-  VERSION = "0.2.0"
+  VERSION = '0.3.0'
 end

data/spec/point_spec.rb

@@ -10,19 +10,19 @@ describe GosuEnhanced::Point do
 
     it 'should work with negative values' do
       point = GosuEnhanced::Point.new( -10, 20 )
-      expect( point.x ).to eq -10
+      expect( point.x ).to eq( -10 )
       expect( point.y ).to eq 20
 
       point = GosuEnhanced::Point.new( 10, -20 )
       expect( point.x ).to eq 10
-      expect( point.y ).to eq -20
+      expect( point.y ).to eq( -20 )
 
       point = GosuEnhanced::Point.new( -10, -20 )
-      expect( point.x ).to eq -10
-      expect( point.y ).to eq -20
+      expect( point.x ).to eq( -10 )
+      expect( point.y ).to eq( -20 )
     end
   end
-  
+
   describe '#offset' do
     it 'should work with another Point' do
       point  = GosuEnhanced::Point.new( 10, 20 )
@@ -31,6 +31,13 @@ describe GosuEnhanced::Point do
       expect( opoint.y ).to eq 60
     end
 
+    it 'should work with a Size' do
+      point  = GosuEnhanced::Point.new( 10, 20 )
+      opoint = point.offset( GosuEnhanced::Size.new( 50, 60 ) )
+      expect( opoint.x ).to eq 60
+      expect( opoint.y ).to eq 80
+    end
+
     it 'should work with two positive values' do
       point  = GosuEnhanced::Point.new( 10, 20 )
       opoint = point.offset( 40, 50 )
@@ -48,11 +55,11 @@ describe GosuEnhanced::Point do
     it 'should work with values that result in negative co-ordinates' do
       point  = GosuEnhanced::Point.new( 60, 80 )
       opoint = point.offset( -80, -150 )
-      expect( opoint.x ).to eq -20
-      expect( opoint.y ).to eq -70
+      expect( opoint.x ).to eq( -20 )
+      expect( opoint.y ).to eq( -70 )
     end
   end
-  
+
   describe '#move_by!' do
     it 'should work with another Point' do
       point  = GosuEnhanced::Point.new( 10, 20 )
@@ -60,7 +67,14 @@ describe GosuEnhanced::Point do
       expect( point.x ).to eq 40
       expect( point.y ).to eq 60
     end
-    
+
+    it 'should work with a Size' do
+      point  = GosuEnhanced::Point.new( 10, 20 )
+      point.move_by!( GosuEnhanced::Size.new( 40, 50 ) )
+      expect( point.x ).to eq 50
+      expect( point.y ).to eq 70
+    end
+
     it 'should work with two positive values' do
       point  = GosuEnhanced::Point.new( 10, 20 )
       point.move_by!( 40, 50 )
@@ -78,11 +92,11 @@ describe GosuEnhanced::Point do
     it 'should work with values that result in negative co-ordinates' do
       point  = GosuEnhanced::Point.new( 60, 80 )
       point.move_by!( -80, -150 )
-      expect( point.x ).to eq -20
-      expect( point.y ).to eq -70
+      expect( point.x ).to eq( -20 )
+      expect( point.y ).to eq( -70 )
     end
   end
-  
+
   describe '#move_to!' do
     it 'should work with another Point' do
       point  = GosuEnhanced::Point.new( 10, 20 )
@@ -90,7 +104,7 @@ describe GosuEnhanced::Point do
       expect( point.x ).to eq 30
       expect( point.y ).to eq 40
     end
-    
+
     it 'should work with two positive values' do
       point  = GosuEnhanced::Point.new( 10, 20 )
       point.move_to!( 40, 50 )
@@ -101,26 +115,30 @@ describe GosuEnhanced::Point do
     it 'should work with two negative values' do
       point  = GosuEnhanced::Point.new( 60, 80 )
       point.move_to!( -40, -50 )
-      expect( point.x ).to eq -40
-      expect( point.y ).to eq -50
+      expect( point.x ).to eq( -40 )
+      expect( point.y ).to eq( -50 )
     end
   end
-  
+
   # This might seem laboured, but I have run foul of dup before
-  
+
   describe '#dup' do
     it 'should make a copy of the Point' do
       point  = GosuEnhanced::Point.new( 10, 20 )
       npoint = point.dup
+
       expect( point.x ).to eq 10
       expect( point.y ).to eq 20
+
       expect( npoint.x ).to eq 10
       expect( npoint.y ).to eq 20
-      point.move_to!( 40, 50 )
-      expect( point.x ).to eq 40
-      expect( point.y ).to eq 50
-      expect( npoint.x ).to eq 10
-      expect( npoint.y ).to eq 20
+
+      npoint.move_to!( 40, 50 )
+      expect( npoint.x ).to eq 40
+      expect( npoint.y ).to eq 50
+
+      expect( point.x ).to eq 10
+      expect( point.y ).to eq 20
     end
   end
 end

data/spec/region_delegation_spec.rb

@@ -3,46 +3,53 @@ require 'spec_helper'
 describe GosuEnhanced::Region do
   let( :point ) { GosuEnhanced::Point.new( 10, 20 ) }
   let( :size )  { GosuEnhanced::Size.new( 30, 40 ) }
-  
-  describe '#y' do
-    it 'should return the top (y) co-ordinate' do |variable|
+
+  describe '#x' do
+    it 'should return the left (x) co-ordinate' do
       reg = GosuEnhanced::Region.new( point, size )
-      expect( reg.y ).to eq 20
+      expect( reg.x ).to eq 10
     end
   end
 
-  describe '#x' do
-    it 'should return the left (x) co-ordinate' do |variable|
+  describe '#y' do
+    it 'should return the top (y) co-ordinate' do
       reg = GosuEnhanced::Region.new( point, size )
-      expect( reg.x ).to eq 10
+      expect( reg.y ).to eq 20
     end
   end
 
   describe '#width' do
-    it 'should return the width' do |variable|
+    it 'should return the width' do
       reg = GosuEnhanced::Region.new( point, size )
       expect( reg.width ).to eq 30
     end
   end
 
   describe '#height' do
-    it 'should return the height' do |variable|
+    it 'should return the height' do
       reg = GosuEnhanced::Region.new( point, size )
       expect( reg.height ).to eq 40
     end
   end
-  
+
   describe '#move_by!' do
     it 'should work with a Point' do
       reg = GosuEnhanced::Region.new( point, size )
       reg.move_by!( GosuEnhanced::Point.new( 30, 40 ) )
       expect( reg.left ).to eq 40
       expect( reg.top ).to  eq 60
-      
+
       expect( point.x ).to eq 10
       expect( point.y ).to eq 20
     end
-    
+
+    it 'should work with a Size' do
+      reg = GosuEnhanced::Region.new( point, size )
+      reg.move_by!( GosuEnhanced::Size.new( 40, 50 ) )
+      expect( reg.left ).to eq 50
+      expect( reg.top ).to  eq 70
+    end
+
     it 'should work with two positive values' do
       reg = GosuEnhanced::Region.new( point, size )
       reg.move_by!( 40, 50 )
@@ -60,22 +67,22 @@ describe GosuEnhanced::Region do
     it 'should work with values that result in negative co-ordinates' do
       reg = GosuEnhanced::Region.new( point, size )
       reg.move_by!( -80, -150 )
-      expect( reg.left ).to eq -70
-      expect( reg.top ).to  eq -130
+      expect( reg.left ).to eq( -70 )
+      expect( reg.top ).to  eq( -130 )
     end
   end
-  
+
   describe '#move_to!' do
     it 'should work with a Point' do
       reg = GosuEnhanced::Region.new( point, size )
       reg.move_to!( GosuEnhanced::Point.new( 30, 40 ) )
       expect( reg.left ).to eq 30
       expect( reg.top ).to  eq 40
-      
+
       expect( point.x ).to eq 10
       expect( point.y ).to eq 20
     end
-    
+
     it 'should work with two positive values' do
       reg = GosuEnhanced::Region.new( point, size )
       reg.move_to!( 40, 50 )
@@ -86,67 +93,67 @@ describe GosuEnhanced::Region do
     it 'should work with two negative values' do
       reg = GosuEnhanced::Region.new( point, size )
       reg.move_to!( -5, -10 )
-      expect( reg.left ).to eq -5
-      expect( reg.top ).to  eq -10
-    end
-
-    describe '#inflate!' do
-      it 'should work with a Size' do
-        reg = GosuEnhanced::Region.new( point, size )
-        reg.inflate!( GosuEnhanced::Size.new( 30, 40 ) )
-        expect( reg.width ).to eq 60
-        expect( reg.height ).to eq 80
-      
-        expect( size.width ).to eq 30
-        expect( size.height ).to eq 40
-      end
-
-      it 'should work with two values' do
-        reg = GosuEnhanced::Region.new( point, size )
-        reg.inflate!( 40, 50 )
-        expect( reg.width ).to eq 70
-        expect( reg.height ).to eq 90
-      end
-
-      it 'should work with negative values' do
-        reg = GosuEnhanced::Region.new( point, size )
-        reg.inflate!( -20, -35 )
-        expect( reg.width ).to eq 10
-        expect( reg.height ).to eq 5
-      end
-
-      it 'should raise an error with out-of-range values' do
-        reg = GosuEnhanced::Region.new( point, size )
-        expect { reg.inflate!( -50, -20 ) }.to raise_error Exception
-        expect { reg.inflate!( -25, -60 ) }.to raise_error Exception
-        expect { reg.inflate!( -50, -70 ) }.to raise_error Exception
-      end
-    end
-
-    describe '#deflate!' do
-      it 'should work with a Size' do
-        reg = GosuEnhanced::Region.new( point, size )
-        reg.deflate!( GosuEnhanced::Size.new( 20, 35 ) )
-        expect( reg.width ).to eq 10
-        expect( reg.height ).to eq 5
-    
-        expect( size.width ).to eq 30
-        expect( size.height ).to eq 40
-      end
-
-      it 'should work with two values' do
-        reg = GosuEnhanced::Region.new( point, size )
-        reg.deflate!( 10, 25 )
-        expect( reg.width ).to eq 20
-        expect( reg.height ).to eq 15
-      end
-
-      it 'should raise an error for out-of-range values' do
-        reg = GosuEnhanced::Region.new( point, size )
-        expect { reg.deflate!( 25, 50 ) }.to raise_error Exception
-        expect { reg.deflate!( 60, 35 ) }.to raise_error Exception
-        expect { reg.deflate!( 80, 70 ) }.to raise_error Exception
-      end
+      expect( reg.left ).to eq( -5 )
+      expect( reg.top ).to  eq( -10 )
+    end
+  end
+
+  describe '#inflate!' do
+    it 'should work with a Size' do
+      reg = GosuEnhanced::Region.new( point, size )
+      reg.inflate!( GosuEnhanced::Size.new( 30, 40 ) )
+      expect( reg.width ).to eq 60
+      expect( reg.height ).to eq 80
+
+      expect( size.width ).to eq 30
+      expect( size.height ).to eq 40
+    end
+
+    it 'should work with two values' do
+      reg = GosuEnhanced::Region.new( point, size )
+      reg.inflate!( 40, 50 )
+      expect( reg.width ).to eq 70
+      expect( reg.height ).to eq 90
+    end
+
+    it 'should work with negative values' do
+      reg = GosuEnhanced::Region.new( point, size )
+      reg.inflate!( -20, -35 )
+      expect( reg.width ).to eq 10
+      expect( reg.height ).to eq 5
+    end
+
+    it 'should raise an error with out-of-range values' do
+      reg = GosuEnhanced::Region.new( point, size )
+      expect { reg.inflate!( -50, -20 ) }.to raise_error Exception
+      expect { reg.inflate!( -25, -60 ) }.to raise_error Exception
+      expect { reg.inflate!( -50, -70 ) }.to raise_error Exception
+    end
+  end
+
+  describe '#deflate!' do
+    it 'should work with a Size' do
+      reg = GosuEnhanced::Region.new( point, size )
+      reg.deflate!( GosuEnhanced::Size.new( 20, 35 ) )
+      expect( reg.width ).to eq 10
+      expect( reg.height ).to eq 5
+
+      expect( size.width ).to eq 30
+      expect( size.height ).to eq 40
+    end
+
+    it 'should work with two values' do
+      reg = GosuEnhanced::Region.new( point, size )
+      reg.deflate!( 10, 25 )
+      expect( reg.width ).to eq 20
+      expect( reg.height ).to eq 15
+    end
+
+    it 'should raise an error for out-of-range values' do
+      reg = GosuEnhanced::Region.new( point, size )
+      expect { reg.deflate!( 25, 50 ) }.to raise_error Exception
+      expect { reg.deflate!( 60, 35 ) }.to raise_error Exception
+      expect { reg.deflate!( 80, 70 ) }.to raise_error Exception
     end
   end
 end

data/spec/region_spec.rb

@@ -3,29 +3,29 @@ require 'spec_helper'
 describe GosuEnhanced::Region do
   let( :point ) { GosuEnhanced::Point.new( 10, 20 ) }
   let( :size )  { GosuEnhanced::Size.new( 30, 40 ) }
-  
+
   describe '#initialize' do
     it 'should work with a Point and a Size' do
       reg = GosuEnhanced::Region.new( point, size )
     end
   end
-  
+
   describe '#position' do
     it 'should return the position as a Point' do
       reg = GosuEnhanced::Region.new( point, size )
       expect( reg.position ).to eq GosuEnhanced::Point.new( 10, 20 )
     end
   end
-  
+
   describe '#top' do
-    it 'should return the top co-ordinate' do |variable|
+    it 'should return the top co-ordinate' do
       reg = GosuEnhanced::Region.new( point, size )
       expect( reg.top ).to eq 20
     end
   end
 
   describe '#left' do
-    it 'should return the left co-ordinate' do |variable|
+    it 'should return the left co-ordinate' do
       reg = GosuEnhanced::Region.new( point, size )
       expect( reg.left ).to eq 10
     end
@@ -37,7 +37,7 @@ describe GosuEnhanced::Region do
       expect( reg.size ).to eq GosuEnhanced::Size.new( 30, 40 )
     end
   end
-  
+
   describe '#contains?' do
     it 'should work with two co-ordinates' do
       reg = GosuEnhanced::Region.new( point, size )
@@ -55,10 +55,10 @@ describe GosuEnhanced::Region do
       expect( reg.contains?( GosuEnhanced::Point.new( 30, 60 ) ) ).to be false
     end
   end
-  
+
   # Unlike the Point and Size, a Region needs a dup override to actually return
   # a duplicate correctly.
-  
+
   describe '#dup' do
     it 'should duplicate a region' do
       reg     = GosuEnhanced::Region.new( point, size )
@@ -76,7 +76,7 @@ describe GosuEnhanced::Region do
       expect( new_reg.size ).to eq GosuEnhanced::Size.new( 40, 50 )
 
       expect( reg.position ).to eq GosuEnhanced::Point.new( 10, 20 )
-      expect( reg.size ).to eq GosuEnhanced::Size.new( 30, 40 )      
+      expect( reg.size ).to eq GosuEnhanced::Size.new( 30, 40 )
     end
   end
 end

data/spec/size_spec.rb

@@ -9,12 +9,12 @@ describe GosuEnhanced::Size do
     end
 
     it 'should reject negative values' do
-      expect { size = GosuEnhanced::Size.new( -10, 20 ) }.to raise_error  Exception
-      expect { size = GosuEnhanced::Size.new( 10, -20 ) }.to raise_error  Exception
-      expect { size = GosuEnhanced::Size.new( -10, -20 ) }.to raise_error Exception
+      expect { GosuEnhanced::Size.new( -10, 20 ) }.to raise_error  Exception
+      expect { GosuEnhanced::Size.new( 10, -20 ) }.to raise_error  Exception
+      expect { GosuEnhanced::Size.new( -10, -20 ) }.to raise_error Exception
     end
   end
-  
+
   describe '#inflate' do
     it 'should work with another Size' do
       size  = GosuEnhanced::Size.new( 10, 20 )
@@ -29,7 +29,7 @@ describe GosuEnhanced::Size do
       expect( esize.width ).to eq 50
       expect( esize.height ).to eq 70
     end
-    
+
     it 'should work with negative values' do
       size  = GosuEnhanced::Size.new( 40, 50 )
       esize = size.inflate( -30, -20 )
@@ -39,9 +39,9 @@ describe GosuEnhanced::Size do
 
     it 'should raise an error with out-of-range values' do
       size  = GosuEnhanced::Size.new( 40, 50 )
-      expect { esize = size.inflate( -50, -20 ) }.to raise_error Exception
-      expect { esize = size.inflate( -30, -60 ) }.to raise_error Exception
-      expect { esize = size.inflate( -50, -70 ) }.to raise_error Exception
+      expect { size.inflate( -50, -20 ) }.to raise_error Exception
+      expect { size.inflate( -30, -60 ) }.to raise_error Exception
+      expect { size.inflate( -50, -70 ) }.to raise_error Exception
     end
   end
 
@@ -59,12 +59,12 @@ describe GosuEnhanced::Size do
       expect( esize.width ).to eq 30
       expect( esize.height ).to eq 10
     end
-    
+
     it 'should raise an error for out-of-range values' do
       size  = GosuEnhanced::Size.new( 70, 60 )
-      expect { esize = size.deflate( 80, 50 ) }.to raise_error Exception
-      expect { esize = size.deflate( 60, 70 ) }.to raise_error Exception
-      expect { esize = size.deflate( 80, 70 ) }.to raise_error Exception
+      expect { size.deflate( 80, 50 ) }.to raise_error Exception
+      expect { size.deflate( 60, 70 ) }.to raise_error Exception
+      expect { size.deflate( 80, 70 ) }.to raise_error Exception
     end
   end
 
@@ -82,7 +82,7 @@ describe GosuEnhanced::Size do
       expect( size.width ).to eq 50
       expect( size.height ).to eq 70
     end
-    
+
     it 'should work with negative values' do
       size  = GosuEnhanced::Size.new( 40, 50 )
       size.inflate!( -30, -20 )
@@ -112,7 +112,7 @@ describe GosuEnhanced::Size do
       expect( size.width ).to eq 30
       expect( size.height ).to eq 10
     end
-    
+
     it 'should raise an error for out-of-range values' do
       size  = GosuEnhanced::Size.new( 70, 60 )
       expect { size.deflate!( 80, 50 ) }.to raise_error Exception
@@ -120,20 +120,24 @@ describe GosuEnhanced::Size do
       expect { size.deflate!( 80, 70 ) }.to raise_error Exception
     end
   end
-  
+
   describe '#dup' do
     it 'should make a copy of the Size' do
       size  = GosuEnhanced::Size.new( 10, 20 )
       nsize = size.dup
+
       expect( size.width ).to eq 10
       expect( size.height ).to eq 20
+
       expect( nsize.width ).to eq 10
       expect( nsize.height ).to eq 20
-      size.inflate!( 40, 50 )
-      expect( size.width ).to eq 50
-      expect( size.height ).to eq 70
-      expect( nsize.width ).to eq 10
-      expect( nsize.height ).to eq 20
+
+      nsize.inflate!( 40, 50 )
+      expect( nsize.width ).to eq 50
+      expect( nsize.height ).to eq 70
+
+      expect( size.width ).to eq 10
+      expect( size.height ).to eq 20
     end
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: gosu_enhanced
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.3.0
 platform: ruby
 authors:
 - Julian Nicholls
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-04-18 00:00:00.000000000 Z
+date: 2014-04-19 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: gosu