geomotion 0.5 → 0.7.0

data/.gitignore

@@ -3,3 +3,4 @@ build
 resources/*.nib
 resources/*.momd
 resources/*.storyboardc
+pkg

data/Gemfile.lock

@@ -0,0 +1,16 @@
+PATH
+  remote: .
+  specs:
+    geomotion (0.6.0)
+
+GEM
+  remote: http://rubygems.org/
+  specs:
+    rake (10.0.3)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  geomotion!
+  rake

data/README.md

@@ -20,25 +20,47 @@ rect_zero = CGRect.empty
 rect_zero.empty?
 => true
 
+# to get the center of the frame, relative to the origin or in absolute coordinates
 rect.center
-=> CGPoint(25, 10) # center as bounds
+=> CGPoint(25, 10) # center relative to bounds
 rect.center(true)
-=> CGPoint(35, 110) # center as frame
+=> CGPoint(35, 110) # center relative to frame
+
+# Other points in the rect can be returned as well, and the same
+# relative/absolute return values are supported (defaults to relative)
+
+         top_left  top_center
+                |  |
+                o--o--o top_right
+                |     |
+    center_left o  x  o center_right
+                |     |
+                o--o--o bottom_right
+                |  |
+      bottom_left  bottom_center
 
 # Operator Overloading
 -rect
 => CGRect(-10, -100, -50, -20)
 
+# union of rects
 rect + CGRect.make(x: 9, y: 99, width: 10, height: 10)
-=> CGRect(9, 99, 50, 20) # == union of rects
+=> rect.union_with(CGRect.make(x: 9, y: 99, width: 10, height: 10))
+=> CGRect(9, 99, 50, 20)
 
+# increases the size, but keeps the origin
 rect + CGSize.make(width: 11, height: 1)
-=> CGRect(10, 100, 61, 21) # == increases the size, but keeps the origin
+=> CGRect(10, 100, 61, 21)
+# not the same as `grow`, which grows the rect in all directions
 
+# moves the rect
 rect + CGPoint.make(x: 10, y: 10)
+=> rect.offset(CGPoint.make(x: 10, y: 10))
 => CGRect(20, 110, 50, 20)
 
+# moves the rect
 rect + UIOffsetMake(10, 10)
+=> rect.offset(UIOffsetMake(10, 10))
 => CGRect(20, 110, 50, 20)
 
 a_point + a_size
@@ -98,6 +120,75 @@ CGRect.layout(rect, above: rect2, right_of: rect3, margins: [0, 0, 10, 15])
 
 ```
 
+## *Relative* vs *Absolute*
+
+When you are positioning frames, you'll be doing so in one of two ways:
+
+1. Two frames relative *to each other*, within a common parent frame
+2. A frame being added *as a child* of another frame
+
+*(generally speaking)*
+
+geomotion is optimized for both cases, but the arsenal of methods is different.
+
+###### frames relative to each other
+
+Any of the location methods (`up, down, left, right, beside, before, above, below`)
+will return a frame that is in the same coordinate system of the receiver, and
+this behavior cannot be changed.
+
+```ruby
+frame = CGRect.new(x: 10, y: 10, width:10, height: 10)
+frame.beside
+# => [[20, 10], [10, 10]]
+
+frame.right(30).down(5).taller(100)
+# => [[10+30, 10+5], [10, 10+100]]
+# aka
+# => [[40, 15], [10, 110]]
+```
+
+Any methods that include the *x* or *y* variable in their name will be absolute.
+
+```ruby
+frame.x
+frame.min_x
+frame.max_x
+frame.mid_x
+frame.y
+frame.min_y
+frame.max_y
+frame.mid_y
+```
+
+###### positions relative to the frame's origin
+
+Any of the position methods that do *NOT* include the *x* or *y* variable will
+*ignore* the *x* and *y* values unless explicitly told to use absolute
+coordinates.
+
+*Note:* These methods will "normalize" the width and height, so even if
+the width or height is negative, these methods will always return positive
+numbers.  If you specify absolute coordinates, the values might be negative, but
+they will also be sorted (x == min, min < mid, mid < max, x + width == max).
+
+```ruby
+frame = CGRect.new(x: 10, y: 10, width:10, height: 10)
+frame.top_left  # => [0, 0]
+frame.top_center  # => [5, 0]
+frame.bottom_right  # => [10, 10]
+
+# use absolute coordinates
+frame.top_left(true)  # => [10, 10]
+frame.top_center(true)  # => [15, 10]
+frame.bottom_right(true)  # => [20, 20]
+
+# negative widths and heights are "corrected" when using absolute coordinates
+frame = CGRect.new(x: 20, y: 20, width:-10, height: -10)
+frame.top_center(true)  # => [15, 10]
+frame.bottom_right(true)  # => [20, 20]
+```
+
 ### CGSize
 
 ```ruby
@@ -131,6 +222,13 @@ size.rect_at_point CGPoint.make(x: 10, y: 30)
 # Initializers
 point = CGPoint.make(x: 10, y: 100)
 
+# Return a modified copy
+point.up(50).left(5)
+=> CGPoint(5, 50)
+# original is not modified, a new point is returned
+point.down(50).right(5)
+=> CGPoint(15, 150)
+
 # Operator Overloading
 -point
 => CGPoint(-10, -100)
@@ -159,4 +257,4 @@ point.inside? CGRect.make(x: 0, y: 0, width: 20, height: 110)
 
 ## Forking
 
-If you have cool/better ideas, pull-request away!
+If you have cool/better ideas, pull-request away!

data/lib/geomotion/cg_point.rb

@@ -12,6 +12,32 @@ class CGPoint
     CGRect.new([self.x, self.y], size)
   end
 
+  # modified points
+  def left(dist = 0)
+    CGPoint.new(self.x - dist, self.y)
+  end
+
+  def right(dist = 0)
+    CGPoint.new(self.x + dist, self.y)
+  end
+
+  def up(dist = 0)
+    CGPoint.new(self.x, self.y - dist)
+  end
+
+  def down(dist = 0)
+    CGPoint.new(self.x, self.y + dist)
+  end
+
+  def round
+    CGPoint.new(self.x.round, self.y.round)
+  end
+
+  def inside?(rect)
+    CGRectContainsPoint(rect, self)
+  end
+
+  # operator
   def +(other)
     case other
     when CGSize
@@ -21,12 +47,24 @@ class CGPoint
     end
   end
 
-  def round
-    CGPoint.new(self.x.round, self.y.round)
+  def *(scale)
+    case scale
+    when Numeric
+      return CGPoint.new(self.x * scale, self.y * scale)
+    else
+      super
+    end
   end
 
-  def inside?(rect)
-    CGRectContainsPoint(rect, self)
+  # it is tempting to define this as self * (1.0/scale) but floating point
+  # errors result in too many errors
+  def /(scale)
+    case scale
+    when Numeric
+      return CGPoint.new(self.x / scale, self.y / scale)
+    else
+      super
+    end
   end
 
   def ==(point)

data/lib/geomotion/cg_rect.rb

@@ -77,6 +77,10 @@ class CGRect
     CGRectGetMinX(self)
   end
 
+  def mid_x
+    CGRectGetMidX(self)
+  end
+
   def max_x
     CGRectGetMaxX(self)
   end
@@ -85,6 +89,10 @@ class CGRect
     CGRectGetMinY(self)
   end
 
+  def mid_y
+    CGRectGetMidY(self)
+  end
+
   def max_y
     CGRectGetMaxY(self)
   end
@@ -196,27 +204,51 @@ class CGRect
     CGRect.new([self.x + self.width + margin, self.y], [width, self.height])
   end
 
-  # locations
+  # positions
+private
+  def cgrect_offset(absolute)
+    if absolute
+      CGPoint.new(self.min_x, self.min_y)
+    else
+      CGPoint.new(0, 0)
+    end
+  end
+
+public
   def center(absolute = false)
-    offset_x = absolute ? self.x : 0
-    offset_y = absolute ? self.y : 0
-    CGPoint.new(offset_x + self.width / 2, offset_y + self.height / 2)
+    cgrect_offset(absolute) + CGPoint.new(self.width / 2, self.height / 2)
+  end
+
+  def top_left(absolute = false)
+    cgrect_offset(absolute) + CGPoint.new(0, 0)
+  end
+
+  def top_center(absolute = false)
+    cgrect_offset(absolute) + CGPoint.new(self.width / 2, 0)
+  end
+
+  def top_right(absolute = false)
+    cgrect_offset(absolute) + CGPoint.new(self.width, 0)
+  end
+
+  def center_right(absolute = false)
+    cgrect_offset(absolute) + CGPoint.new(self.width, self.height / 2)
   end
 
-  def top_left
-    CGPoint.new(CGRectGetMinX(self), CGRectGetMinY(self))
+  def bottom_right(absolute = false)
+    cgrect_offset(absolute) + CGPoint.new(self.width, self.height)
   end
 
-  def top_right
-    CGPoint.new(CGRectGetMaxX(self), CGRectGetMinY(self))
+  def bottom_center(absolute = false)
+    cgrect_offset(absolute) + CGPoint.new(self.width / 2, self.height)
   end
 
-  def bottom_left
-    CGPoint.new(CGRectGetMinX(self), CGRectGetMaxY(self))
+  def bottom_left(absolute = false)
+    cgrect_offset(absolute) + CGPoint.new(0, self.height)
   end
 
-  def bottom_right
-    CGPoint.new(CGRectGetMaxX(self), CGRectGetMaxY(self))
+  def center_left(absolute = false)
+    cgrect_offset(absolute) + CGPoint.new(0, self.height / 2)
   end
 
   # others
@@ -235,11 +267,31 @@ class CGRect
     when CGSize
       return CGRect.new([self.x, self.y], [self.width + other.width, self.height + other.height])
     when CGPoint
-      return CGRectOffset(self, other.x, other.y)
+      return self.offset(other.x, other.y)
     when UIOffset
-      CGRectOffset(self, other.horizontal, other.vertical)
+      return self.offset(other.horizontal, other.vertical)
     when UIEdgeInsets
-      UIEdgeInsetsInsetRect(self, other)
+      return self.inset(other)
+    end
+  end
+
+  def *(scale)
+    case scale
+    when Numeric
+      return CGRect.new(self.origin, self.size * scale)
+    else
+      super
+    end
+  end
+
+  # it is tempting to define this as self * (1.0/scale) but floating point
+  # errors result in too many errors
+  def /(scale)
+    case scale
+    when Numeric
+      return CGRect.new(self.origin, self.size / scale)
+    else
+      super
     end
   end
 
@@ -251,18 +303,30 @@ class CGRect
     CGRectUnion(self, rect)
   end
 
+  def inset(insets)
+    UIEdgeInsetsInsetRect(self, insets)
+  end
+
+  def offset(point_or_x, y=nil)
+    if y
+      CGRectOffset(self, point_or_x, y)
+    else
+      CGRectOffset(self, point_or_x[0], point_or_x[1])
+    end
+  end
+
   def grow(size)
     if size.is_a? Numeric
       size = CGSize.new(size, size)
     end
-    CGRectInset(self, -size.width, -size.height)
+    CGRectInset(self, -size[0], -size[1])
   end
 
   def shrink(size)
     if size.is_a? Numeric
       size = CGSize.new(size, size)
     end
-    CGRectInset(self, size.width, size.height)
+    CGRectInset(self, size[0], size[1])
   end
 
   def empty?

data/lib/geomotion/cg_size.rb

@@ -37,6 +37,26 @@ class CGSize
     end
   end
 
+  def *(scale)
+    case scale
+    when Numeric
+      return CGSize.new(self.width * scale, self.height * scale)
+    else
+      super
+    end
+  end
+
+  # it is tempting to define this as self * (1.0/scale) but floating point
+  # errors result in too many miscalculations
+  def /(scale)
+    case scale
+    when Numeric
+      return CGSize.new(self.width / scale, self.height / scale)
+    else
+      super
+    end
+  end
+
   def infinite?
     infinity = CGRect.null[0][0]  # null rects are rects with infinite width & height
     self.width == infinity or self.height == infinity

data/lib/geomotion/version.rb

@@ -1,3 +1,3 @@
 module Geomotion
-  VERSION = "0.5"
+  VERSION = "0.7.0"
 end

data/spec/cg_point_spec.rb

@@ -20,6 +20,41 @@ describe "CGPoint" do
     end
   end
 
+  describe "#up" do
+    it "should work" do
+      point = CGPointMake(1, 1).up(1)
+      CGPointEqualToPoint(point, CGPointMake(1, 0)).should == true
+    end
+  end
+
+  describe "#down" do
+    it "should work" do
+      point = CGPointMake(1, 1).down(1)
+      CGPointEqualToPoint(point, CGPointMake(1, 2)).should == true
+    end
+  end
+
+  describe "#left" do
+    it "should work" do
+      point = CGPointMake(1, 1).left(1)
+      CGPointEqualToPoint(point, CGPointMake(0, 1)).should == true
+    end
+  end
+
+  describe "#right" do
+    it "should work" do
+      point = CGPointMake(1, 1).right(1)
+      CGPointEqualToPoint(point, CGPointMake(2, 1)).should == true
+    end
+  end
+
+  describe "#chaining up().down().left().right()" do
+    it "should work" do
+      point = CGPointMake(1, 1).up(2).down(1).left(2).right(1)
+      CGPointEqualToPoint(point, CGPointMake(0, 0)).should == true
+    end
+  end
+
   describe "#+" do
     it "should work with CGSize" do
       size = CGSizeMake(20, 30)
@@ -32,6 +67,24 @@ describe "CGPoint" do
     end
   end
 
+  describe "#*" do
+    it "should work with Numeric" do
+      point = CGPointMake(12, 24)
+      bigger = point * 3
+      bigger.x.should == 36
+      bigger.y.should == 72
+    end
+  end
+
+  describe "#/" do
+    it "should work with Numeric" do
+      point = CGPointMake(12, 24)
+      smaller = point / 3
+      smaller.x.should == 4
+      smaller.y.should == 8
+    end
+  end
+
   describe "#- (unary)" do
     it "should work" do
       point = CGPoint.make(x: 100, y: 200)

data/spec/cg_rect_spec.rb

@@ -142,6 +142,11 @@ describe "CGRect" do
     it "returns value when no args" do
       @rect.x.should == 10
     end
+    it "returns min_x when width is negative" do
+      rect = CGRect.make(x: 110, y: 10, width: -100, height: 100)
+      rect.x.should == 10
+      rect.origin.x.should == 110
+    end
 
     it "returns copy when has args" do
       rect = @rect.x(20)
@@ -162,6 +167,11 @@ describe "CGRect" do
     it "returns value when no args" do
       @rect.y.should == 100
     end
+    it "returns min_y when height is negative" do
+      rect = CGRect.make(x: 10, y: 110, width: 100, height: -100)
+      rect.y.should == 10
+      rect.origin.y.should == 110
+    end
 
     it "returns copy when has args" do
       rect = @rect.y(20)
@@ -182,7 +192,10 @@ describe "CGRect" do
     it "returns value when no args" do
       @rect.width.should == 50
     end
-
+    it "always returns positive width" do
+      rect = CGRect.make(x: 10, y: 110, width: -100, height: -100)
+      rect.width.should == 100
+    end
     it "returns copy when has args" do
       rect = @rect.width(20)
       rect.is_a?(CGRect).should == true
@@ -202,7 +215,10 @@ describe "CGRect" do
     it "returns value when no args" do
       @rect.height.should == 20
     end
-
+    it "always returns positive height" do
+      rect = CGRect.make(x: 10, y: 110, width: -100, height: -100)
+      rect.height.should == 100
+    end
     it "returns copy when has args" do
       rect = @rect.height(50)
       rect.is_a?(CGRect).should == true
@@ -218,6 +234,51 @@ describe "CGRect" do
     end
   end
 
+  describe "#min_x, #mid_x, #max_x, #min_y, #mid_y, #max_y" do
+    before do
+      @min_rect = CGRect.make(x: 10, y: 10, width: 100, height: 100)
+      @min_rect_negative = CGRect.make(x: 110, y: 110, width: -100, height: -100)
+    end
+
+    it "#min_x works" do
+      @min_rect.min_x.should == 10
+    end
+    it "#mid_x works" do
+      @min_rect.mid_x.should == 60
+    end
+    it "#max_x works" do
+      @min_rect.max_x.should == 110
+    end
+    it "#min_x works with negative width" do
+      @min_rect_negative.min_x.should == 10
+    end
+    it "#mid_x works with negative width" do
+      @min_rect_negative.mid_x.should == 60
+    end
+    it "#max_x works with negative width" do
+      @min_rect_negative.max_x.should == 110
+    end
+
+    it "#min_y works" do
+      @min_rect.min_y.should == 10
+    end
+    it "#mid_y works" do
+      @min_rect.mid_y.should == 60
+    end
+    it "#max_y works" do
+      @min_rect.max_y.should == 110
+    end
+    it "#min_y works with negative height" do
+      @min_rect_negative.min_y.should == 10
+    end
+    it "#mid_y works with negative height" do
+      @min_rect_negative.mid_y.should == 60
+    end
+    it "#max_y works with negative height" do
+      @min_rect_negative.max_y.should == 110
+    end
+  end
+
   describe "#left" do
     it "works" do
       rect = CGRect.empty
@@ -333,16 +394,30 @@ describe "CGRect" do
       rect = CGRect.make(x: 10, y: 20, width: 100, height: 200)
       point = rect.top_left
       point.is_a?(CGPoint).should == true
+      CGPointEqualToPoint(point, CGPointMake(0, 0)).should == true
+    end
+
+    it "works as relative" do
+      rect = CGRect.make(x: 10, y: 20, width: 100, height: 200)
+      point = rect.top_left(true)
+      point.is_a?(CGPoint).should == true
       CGPointEqualToPoint(point, CGPointMake(10, 20)).should == true
     end
   end
 
-  describe "#bottom_left" do
+  describe "#top_center" do
     it "works" do
       rect = CGRect.make(x: 10, y: 20, width: 100, height: 200)
-      point = rect.bottom_left
+      point = rect.top_center
       point.is_a?(CGPoint).should == true
-      CGPointEqualToPoint(point, CGPointMake(10, 220)).should == true
+      CGPointEqualToPoint(point, CGPointMake(50, 0)).should == true
+    end
+
+    it "works as relative" do
+      rect = CGRect.make(x: 10, y: 20, width: 100, height: 200)
+      point = rect.top_center(true)
+      point.is_a?(CGPoint).should == true
+      CGPointEqualToPoint(point, CGPointMake(60, 20)).should == true
     end
   end
 
@@ -351,19 +426,97 @@ describe "CGRect" do
       rect = CGRect.make(x: 10, y: 20, width: 100, height: 200)
       point = rect.top_right
       point.is_a?(CGPoint).should == true
+      CGPointEqualToPoint(point, CGPointMake(100, 0)).should == true
+    end
+
+    it "works as relative" do
+      rect = CGRect.make(x: 10, y: 20, width: 100, height: 200)
+      point = rect.top_right(true)
+      point.is_a?(CGPoint).should == true
       CGPointEqualToPoint(point, CGPointMake(110, 20)).should == true
     end
   end
 
+  describe "#center_right" do
+    it "works" do
+      rect = CGRect.make(x: 10, y: 20, width: 100, height: 200)
+      point = rect.center_right
+      point.is_a?(CGPoint).should == true
+      CGPointEqualToPoint(point, CGPointMake(100, 100)).should == true
+    end
+
+    it "works as relative" do
+      rect = CGRect.make(x: 10, y: 20, width: 100, height: 200)
+      point = rect.center_right(true)
+      point.is_a?(CGPoint).should == true
+      CGPointEqualToPoint(point, CGPointMake(110, 120)).should == true
+    end
+  end
+
   describe "#bottom_right" do
     it "works" do
       rect = CGRect.make(x: 10, y: 20, width: 100, height: 200)
       point = rect.bottom_right
       point.is_a?(CGPoint).should == true
+      CGPointEqualToPoint(point, CGPointMake(100, 200)).should == true
+    end
+
+    it "works as relative" do
+      rect = CGRect.make(x: 10, y: 20, width: 100, height: 200)
+      point = rect.bottom_right(true)
+      point.is_a?(CGPoint).should == true
       CGPointEqualToPoint(point, CGPointMake(110, 220)).should == true
     end
   end
 
+  describe "#bottom_center" do
+    it "works" do
+      rect = CGRect.make(x: 10, y: 20, width: 100, height: 200)
+      point = rect.bottom_center
+      point.is_a?(CGPoint).should == true
+      CGPointEqualToPoint(point, CGPointMake(50, 200)).should == true
+    end
+
+    it "works as relative" do
+      rect = CGRect.make(x: 10, y: 20, width: 100, height: 200)
+      point = rect.bottom_center(true)
+      point.is_a?(CGPoint).should == true
+      CGPointEqualToPoint(point, CGPointMake(60, 220)).should == true
+    end
+  end
+
+  describe "#bottom_left" do
+    it "works" do
+      rect = CGRect.make(x: 10, y: 20, width: 100, height: 200)
+      point = rect.bottom_left
+      point.is_a?(CGPoint).should == true
+      CGPointEqualToPoint(point, CGPointMake(0, 200)).should == true
+    end
+
+    it "works as relative" do
+      rect = CGRect.make(x: 10, y: 20, width: 100, height: 200)
+      point = rect.bottom_left(true)
+      point.is_a?(CGPoint).should == true
+      CGPointEqualToPoint(point, CGPointMake(10, 220)).should == true
+    end
+  end
+
+  describe "#center_left" do
+    it "works" do
+      rect = CGRect.make(x: 10, y: 20, width: 100, height: 200)
+      point = rect.center_left
+      point.is_a?(CGPoint).should == true
+      CGPointEqualToPoint(point, CGPointMake(0, 100)).should == true
+    end
+
+    it "works as relative" do
+      rect = CGRect.make(x: 10, y: 20, width: 100, height: 200)
+      point = rect.center_left(true)
+      point.is_a?(CGPoint).should == true
+      CGPointEqualToPoint(point, CGPointMake(10, 120)).should == true
+    end
+  end
+
   describe "#center" do
     it "works" do
       point = CGRect.make(width: 100, height: 100).center
@@ -443,12 +596,57 @@ describe "CGRect" do
     end
 
     it "works with UIEdgeInsets" do
-      inset = UIEdgeInsetsMake(10, 10, 10, 5)
-      rect = (@rect + inset)
+      insets = UIEdgeInsetsMake(10, 10, 10, 5)
+      rect = (@rect + insets)
       CGRectEqualToRect(rect, CGRectMake(20, 110, 35, 0)).should == true
     end
   end
 
+  describe "offset" do
+    it "works with x, y" do
+      rect = @rect.offset(50, 20)
+      CGRectEqualToRect(rect, CGRectMake(60, 120, 50, 20)).should == true
+    end
+
+    it "works with CGPoint" do
+      point = CGPointMake(50, 20)
+      rect = @rect.offset(point)
+      CGRectEqualToRect(rect, CGRectMake(60, 120, 50, 20)).should == true
+    end
+
+    it "works with UIOffset" do
+      offset = UIOffsetMake(50, 20)
+      rect = @rect.offset(offset)
+      CGRectEqualToRect(rect, CGRectMake(60, 120, 50, 20)).should == true
+    end
+  end
+
+  describe "inset" do
+    it "works with UIEdgeInsets" do
+      insets = UIEdgeInsetsMake(10, 10, 10, 5)
+      rect = @rect.inset(insets)
+      CGRectEqualToRect(rect, CGRectMake(20, 110, 35, 0)).should == true
+    end
+  end
+
+  describe "#*" do
+    it "should work with Numeric" do
+      rect = CGRectMake(0, 0, 12, 24)
+      bigger = rect * 3
+      bigger.size.width.should == 36
+      bigger.size.height.should == 72
+    end
+  end
+
+  describe "#/" do
+    it "should work with Numeric" do
+      rect = CGRectMake(0, 0, 12, 24)
+      smaller = rect / 3
+      smaller.size.width.should == 4
+      smaller.size.height.should == 8
+    end
+  end
+
   describe "#intersection_with" do
     it "should work" do
       lower_rect = CGRectMake(0, 0, 100, 100)
@@ -489,5 +687,10 @@ describe "CGRect" do
       rect = @rect.shrink(CGSizeMake(20, 10))
       CGRectEqualToRect(rect, CGRectMake(30, 110, 10, 0)).should == true
     end
+
+    it "should work with Array" do
+      rect = @rect.shrink([20, 10])
+      CGRectEqualToRect(rect, CGRectMake(30, 110, 10, 0)).should == true
+    end
   end
-end
+end

data/spec/cg_size_spec.rb

@@ -46,6 +46,24 @@ describe "CGSize" do
     end
   end
 
+  describe "#*" do
+    it "should work with Numeric" do
+      size = CGSizeMake(12, 24)
+      bigger = size * 3
+      bigger.width.should == 36
+      bigger.height.should == 72
+    end
+  end
+
+  describe "#/" do
+    it "should work with Numeric" do
+      size = CGSizeMake(12, 24)
+      smaller = size / 3
+      smaller.width.should == 4
+      smaller.height.should == 8
+    end
+  end
+
   describe "#infinite?" do
     it "should return true" do
       infinite = CGSize.infinite

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: geomotion
 version: !ruby/object:Gem::Version
-  version: '0.5'
+  version: 0.7.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-12-27 00:00:00.000000000 Z
+date: 2013-02-14 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
@@ -36,6 +36,7 @@ extra_rdoc_files: []
 files:
 - .gitignore
 - Gemfile
+- Gemfile.lock
 - Geomotion.gemspec
 - README.md
 - Rakefile
@@ -68,7 +69,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 1.8.23
+rubygems_version: 1.8.24
 signing_key: 
 specification_version: 3
 summary: A RubyMotion Geometry Wrapper
@@ -76,3 +77,4 @@ test_files:
 - spec/cg_point_spec.rb
 - spec/cg_rect_spec.rb
 - spec/cg_size_spec.rb
+has_rdoc: