geomotion 0.0.2 → 0.1

data/README.md

@@ -1,46 +1,151 @@
 # Geomotion
 
-iOS geometry is too verbose for Ruby. Geomotion tries to fix that.
+iOS Geometry in idiomatic Ruby. Exhaustively tested. What's not to love?
 
-## Usage
+## Features
+
+### CGRect
 
 ```ruby
-# More idiomatic initializer
+# Initializers
 rect = CGRect.make(x: 10, y: 100, width: 50, height: 20)
+another_way = CGRect.make(origin: CGPoint, size: CGSize)
 
-# These do what you think
+# Getters
 [rect.x, rect.y, rect.width, rect.height]
 => [10, 100, 50, 20]
 
-# Chainable methods for adjusting frames
+rect_zero = CGRect.empty
+=> CGRect(0, 0, 0, 0)
+rect_zero.empty?
+=> true
+
+rect.center
+=> CGPoint(25, 10) # center as bounds
+rect.center(true)
+=> CGPoint(35, 110) # center as frame
+
+# Operator Overloading
+rect + CGRect.make(x: 9, y: 99, width: 10, height: 10)
+=> CGRect(9, 99, 50, 20) # == union of rects
+
+rect + CGSize.new(11, 1)
+=> CGRect(10, 100, 61, 21) # == increases the size, but keeps the origin
+
+rect + CGPoint.new(10, 10)
+=> CGRect.new(20, 110, 50, 20)
+
+rect + UIOffsetMake(10, 10)
+=> CGRect.new(20, 110, 50, 20)
+
+a_point + a_size
+=> CGRect # a point and a size make a rectangle. makes sense, right?
+
+# Union and Intersection
+rect.union_with CGRect.new(9, 99, 10, 10)
+=> CGRect(9, 99, 50, 20)
+
+rect.intersection_with CGRect.new(9, 99, 10, 10)
+=> CGRect.new(10, 100, 10, 10)
+
+# Growing and shrinking
+# The center stays the same. Think margins!
+rect.grow(CGSize.new(10, 20))
+=> CGRect.new(5, 90, 60, 40)
+
+rect.shrink(10)
+=> CGRect.new(15, 105, 40, 10)
+
+# Powerful layout adjustments with chainable methods
 view = UIView.alloc.initWithFrame rect.below.width(100).height(10)
 view.frame
-=> #<CGRect origin=#<CGPoint x=10.0 y=120.0> size=#<CGSize width=100.0 height=10.0>>
+=> CGRect(10, 120, 100, 10)
 
 view2 = UIView.alloc.initWithFrame rect.beside(10)
 view2.frame
-=> #<CGRect origin=#<CGPoint x=70.0 y=100.0> size=#<CGSize width=50.0 height=20.0>>
+=> CGRect(70, 100, 50, 20.0)
 
+# More examples of adjustments
+rect = CGRect.make(x: 10, y: 100, width: 50, height: 20)
 [rect.right(20).x, rect.left(20).x, rect.up(20).y, rect.down(20).y]
 => [30, -10, 80, 120]
 
+# Layout "above" and "before" rectangles
+# (default offset is the rectangle's width or height)
+rect.before(5)
+=> CGRect.new(-45, 100, 50, 20)
+rect.before(5, width:20)
+=> CGRect.new(-15, 100, 20, 20)
+
+rect.above(5)
+=> CGRect.new(10, 75, 50, 20)
+rect.above(5, height:10)
+=> CGRect.new(10, 85, 50, 10)
+
 # Layout a rect relative to others
-rect2 = CGRect.new [50, 50], [100, 100]
-rect3 = CGRect.new [100, 200], [20, 20]
+rect2 = CGRect.make(x: 50, y: 50, width: 100, height: 100)
+rect3 = CGRect.make(x:100, y: 200, width: 20, height: 20)
 
 CGRect.layout(rect, above: rect2, right_of: rect3)
-=> #<CGRect origin=#<CGPoint x=120.0 y=30.0> size=#<CGSize width=50.0 height=20.0>>
+=> CGRect(120, 30, 50, 20)
 
 # Also supports margins
 CGRect.layout(rect, above: rect2, right_of: rect3, margins: [0, 0, 10, 15])
-=> #<CGRect origin=#<CGPoint x=135.0 y=20.0> size=#<CGSize width=50.0 height=20.0>>
+=> CGRect(135, 20, 50, 20)
+
+```
+
+### CGSize
+
+```ruby
+# Initializers
+size = CGSize.make(width: 50, height: 20)
+
+# Getters
+size_zero = CGSize.empty
+=> CGSize(0, 0)
+size_zero.empty?
+=> true
+
+# Operator Overloading
+size + CGSize.make(width: 100, height: 50)
+=> CGSize(150, 70)
+
+size + CGPoint.make(x: 10, y: 30)
+=> CGRect(10, 30, 50, 20)
+
+# Combine with CGPoint
+size.rect_at_point CGPoint.make(x: 10, y: 30)
+=> CGRect(10, 30, 50, 20)
+```
+
+### CGPoint
+
+```ruby
+# Initializers
+point = CGPoint.make(x: 10, y: 100)
+
+# Operator Overloading
+point + CGPoint.make(x: 20, y: 40)
+=> CGPoint(30, 140)
+
+point + CGSize.make(width: 50, height: 20)
+=> CGRect(10, 100, 50, 20)
+
+# Combine with CGSize
+point.rect_of_size CGSize.make(width: 50, height: 20)
+=> CGRect(10, 100, 50, 20)
+
+# Combine with CGRect
+point.inside? CGRect.make(x: 0, y: 0, width: 20, height: 110)
+=> true
 ```
 
 ## Install
 
 1. `gem install geomotion`
 
-2. Add `require geomotion` in your `Rakefile`.
+2. Add `require 'geomotion'` in your `Rakefile`.
 
 
 ## Forking

data/lib/geomotion/cg_point.rb

@@ -0,0 +1,36 @@
+class CGPoint
+  # CGPoint.make(x: 10, y: 30)
+  def self.make(options = {})
+    CGPoint.new(options[:x] || 0, options[:y] || 0)
+  end
+
+  # size = CGSize.make width: 100, height: 100
+  # point = CPPoint.make x:0, y:10
+  # point.rect_of_size(point)  # => CGRect([0, 10], [100, 100])
+  # point.rect_of_size([10, 20])  # => CGRect([10, 20], [100, 100])
+  def rect_of_size(size)
+    CGRect.new([self.x, self.y], size)
+  end
+
+  def +(other)
+    case other
+    when CGSize
+      return self.rect_of_size(other)
+    when CGPoint
+      return CGPoint.new(self.x + other.x, self.y + other.y)
+    end
+  end
+
+  def round
+    CGPoint.new(self.x.round, self.y.round)
+  end
+
+  def inside?(rect)
+    CGRectContainsPoint(rect, self)
+  end
+
+  def ==(point)
+    point.is_a?(CGPoint) && CGPointEqualToPoint(self, point)
+  end
+
+end

data/lib/geomotion/cg_rect.rb

@@ -1,9 +1,31 @@
 class CGRect
   # CGRect.make(x: 10, y: 30)
+  # CGRect.make(x: 10, y: 30, width:100, height: 20)
   def self.make(options = {})
+    if options[:origin]
+      options[:x] = options[:origin].x
+      options[:y] = options[:origin].y
+    end
+    if options[:size]
+      options[:width] = options[:size].width
+      options[:height] = options[:size].height
+    end
     CGRect.new([options[:x] || 0, options[:y] || 0], [options[:width] || 0, options[:height] || 0])
   end
 
+  def self.empty
+    # Don't return CGRectZero; can be mutated
+    CGRect.make
+  end
+
+  def self.null
+    CGRectNull
+  end
+
+  def self.infinite
+    self.new([0, 0], CGSize.infinite)
+  end
+
   # OPTIONS: [:above, :below, :left_of, :right_of, :margins]
   #   :margins is array of [top, right, bottom, left]
   # EX CGRect.layout(rect1, above: rect2, left_of: rect3, margins: [0, 10, 20, 0])
@@ -91,10 +113,26 @@ class CGRect
     CGRect.new([self.x, self.y + dist], self.size)
   end
 
+  def above(margin = 0)
+    self.above(margin, height:self.height)
+  end
+
+  def above(margin, height:height)
+    CGRect.new([self.x, self.y - height - margin], [self.width, height])
+  end
+
   def below(margin = 0)
     CGRect.new([self.x, self.y + self.height + margin], self.size)
   end
 
+  def before(margin = 0)
+    self.before(margin, width:self.width)
+  end
+
+  def before(margin, width:width)
+    CGRect.new([self.x - width - margin, self.y], [width, self.height])
+  end
+
   def beside(margin = 0)
     CGRect.new([self.x + self.width + margin, self.y], self.size)
   end
@@ -115,4 +153,77 @@ class CGRect
     CGRect.new([offset_x + ((rect.width - self.width) / 2),
                 offset_y + ((rect.height - self.height) / 2)], self.size)
   end
-end
+
+  def +(other)
+    case other
+    when CGRect
+      return self.union_with(other)
+    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)
+    when UIOffset
+      CGRectOffset(self, other.horizontal, other.vertical)
+    when UIEdgeInsets
+      UIEdgeInsetsInsetRect(self, other)
+    end
+  end
+
+  def intersection_with(rect)
+    CGRectIntersection(self, rect)
+  end
+
+  def union_with(rect)
+    CGRectUnion(self, rect)
+  end
+
+  def grow(size)
+    if size.is_a? Numeric
+      size = CGSize.new(size, size)
+    end
+    CGRectInset(self, -size.width, -size.height)
+  end
+
+  def shrink(size)
+    if size.is_a? Numeric
+      size = CGSize.new(size, size)
+    end
+    CGRectInset(self, size.width, size.height)
+  end
+
+  def empty?
+    CGRectIsEmpty(self)
+  end
+
+  def infinite?
+    self.size.infinite?
+  end
+
+  def null?
+    CGRectIsNull(self)
+  end
+
+  def intersects?(rect)
+    case rect
+    when CGRect
+      CGRectIntersectsRect(self, rect)
+    else
+      super
+    end
+  end
+
+  def contains?(rect_or_point)
+    case rect_or_point
+    when CGPoint
+      CGRectContainsPoint(self, rect_or_point)
+    when CGRect
+      CGRectContainsRect(self, rect_or_point)
+    else
+      super
+    end
+  end
+
+  def ==(rect)
+    rect.is_a?(CGRect) && CGRectEqualToRect(self, rect)
+  end
+end

data/lib/geomotion/cg_size.rb

@@ -0,0 +1,41 @@
+class CGSize
+  # CGSize.make(width: 10, height: 30)
+  def self.make(options = {})
+    CGSize.new(options[:width] || 0, options[:height] || 0)
+  end
+
+  def self.infinite
+    infinity = CGRect.null[0][0]
+    CGSizeMake(infinity, infinity)
+  end
+
+  # size = CGSize.make width: 100, height: 100
+  # point = CPPoint.make x:0, y:10
+  # size.rect_at_point(point)  # => CGRect([0, 10], [100, 100])
+  # size.rect_at_point([10, 20])  # => CGRect([10, 20], [100, 100])
+  def rect_at_point(point)
+    CGRect.new(point, [self.width, self.height])
+  end
+
+  def +(other)
+    case other
+    when CGSize
+      return CGSize.new(self.width + other.width, self.height + other.height)
+    when CGPoint
+      return self.rect_at_point(other)
+    end
+  end
+
+  def infinite?
+    infinity = CGRect.null[0][0]  # null rects are rects with infinite width & height
+    self.width == infinity or self.height == infinity
+  end
+
+  def empty?
+    self == CGSizeZero
+  end
+
+  def ==(size)
+    size.is_a?(CGSize) && CGSizeEqualToSize(self, size)
+  end
+end

data/lib/geomotion/version.rb

@@ -1,3 +1,3 @@
 module Geomotion
-  VERSION = "0.0.2"
+  VERSION = "0.1"
 end

data/spec/cg_point_spec.rb

@@ -0,0 +1,65 @@
+describe "CGPoint" do
+  before do
+    @point = CGPoint.make(x: 10, y: 20)
+  end
+
+  describe ".make" do
+    it "should work with options" do
+      CGPointEqualToPoint(@point, CGPointMake(10, 20)).should == true
+    end
+
+    it "should work with no options" do
+      CGPointEqualToPoint(CGPoint.make, CGPointMake(0, 0)).should == true
+    end
+  end
+
+  describe "#rect_of_size" do
+    it "should work" do
+      size = CGSizeMake(20, 30)
+      @point.rect_of_size(size).should == CGRectMake(10, 20, 20, 30)
+    end
+  end
+
+  describe "#+" do
+    it "should work with CGSize" do
+      size = CGSizeMake(20, 30)
+      (@point + size).should == CGRectMake(10, 20, 20, 30)
+    end
+
+    it "should work with CGPoint" do
+      point = CGPoint.make(x: 100, y: 200)
+      (@point + point).should == CGPointMake(110, 220)
+    end
+  end
+
+  describe "#inside?" do
+    it "should return true" do
+      rect = CGRectMake(0, 0, 100, 100)
+      @point.inside?(rect).should == true
+    end
+
+    it "should return false" do
+      rect = CGRectMake(0, 0, 5, 5)
+      @point.inside?(rect).should == false
+    end
+  end
+
+  describe "#round" do
+    it "should work" do
+      point = CGPointMake(10.4, 11.5).round
+      CGPointEqualToPoint(point, CGPointMake(10, 12)).should == true
+    end
+  end
+
+  describe "#==?" do
+    it "should return true" do
+      point = CGPointMake(10, 20)
+      @point.should == point
+    end
+
+    it "should return false" do
+      point = CGPointMake(20, 10)
+      @point.should != point
+    end
+  end
+end

data/spec/cg_rect_spec.rb

@@ -0,0 +1,381 @@
+describe "CGRect" do
+  before do
+    @rect = CGRect.make(x: 10, y: 100, width: 50, height: 20)
+  end
+
+  describe ".make" do
+    it "should work with options" do
+      CGRectEqualToRect(@rect, CGRectMake(10, 100, 50, 20)).should == true
+    end
+
+    it "should work with nested options" do
+      CGRectEqualToRect(
+        CGRect.make(origin: CGPointMake(10, 100), size: CGSizeMake(50,20)),
+        CGRectMake(10, 100, 50, 20)
+      ).should == true
+    end
+
+    it "should work with no options" do
+      CGRectEqualToRect(CGRect.make, CGRectMake(0, 0, 0, 0)).should == true
+    end
+  end
+
+  describe ".empty" do
+    it "should work" do
+      CGRectIsEmpty(CGRect.empty).should == true
+    end
+  end
+
+  describe "#empty?" do
+    it "should work" do
+      p "ZERO1 #{CGRectZero.inspect}"
+      CGRectZero.empty?.should == true
+    end
+  end
+
+  describe ".null" do
+    it "should work" do
+      CGRectIsNull(CGRect.null).should == true
+    end
+  end
+
+  describe "#null?" do
+    it "should work" do
+      CGRectNull.null?.should == true
+    end
+  end
+
+  # Currently does NOT work due to some strange RM bug?
+=begin
+  describe ".infinite" do
+    it "should work" do
+      CGRectIsInfinite(CGRect.infinite).should == true
+    end
+  end
+=end
+
+  describe "#infinite?" do
+    it "should work" do
+      CGRect.infinite.infinite?.should == true
+    end
+  end
+
+  describe "#intersects?" do
+    it "should work" do
+      left_rect = CGRectMake(0, 0, 100, 100)
+      right_rect = CGRectMake(80, 0, 100, 100)
+      left_rect.intersects?(right_rect).should == true
+    end
+  end
+
+  describe "#contains?" do
+    it "should work with CGPoint" do
+      left_rect = CGRectMake(0, 0, 100, 100)
+      point = CGPointMake(10, 10)
+      left_rect.contains?(point).should == true
+    end
+
+    it "should work with CGRect" do
+      left_rect = CGRectMake(0, 0, 100, 100)
+      inner_rect = CGRectMake(80, 0, 10, 10)
+      left_rect.contains?(inner_rect).should == true
+    end
+  end
+
+  describe "#==" do
+    it "should return true" do
+      @rect.should == CGRectMake(10, 100, 50, 20)
+    end
+
+    it "should return false" do
+      @rect.should != CGRectMake(10, 100, 50, 10)
+    end
+  end
+
+  describe ".layout" do
+    it "should work without margins" do
+      above = CGRectMake(50, 50, 100, 100)
+      right_of = CGRectMake(100, 200, 20, 20)
+
+      no_margins = CGRect.layout(@rect, above: above, right_of: right_of)
+
+      CGRectEqualToRect(no_margins, CGRectMake(120, 30, 50, 20)).should == true
+    end
+
+    it "should work with margins" do
+      above = CGRectMake(50, 50, 100, 100)
+      right_of = CGRectMake(100, 200, 20, 20)
+
+      margins = CGRect.layout(@rect, above: above, right_of: right_of, margins: [0, 0, 10, 15])
+
+      CGRectEqualToRect(margins, CGRectMake(135, 20, 50, 20)).should == true
+    end
+  end
+
+  describe "#x" do
+    it "returns value when no args" do
+      @rect.x.should == 10
+    end
+
+    it "returns copy when has args" do
+      rect = @rect.x(20)
+      rect.is_a?(CGRect).should == true
+      CGRectEqualToRect(rect, CGRectMake(20, 100, 50, 20)).should == true
+    end
+  end
+
+  describe "#x=" do
+    it "sets value" do
+      rect = CGRect.empty
+      rect.x = 20
+      rect.origin.x.should == 20
+    end
+  end
+
+  describe "#y" do
+    it "returns value when no args" do
+      @rect.y.should == 100
+    end
+
+    it "returns copy when has args" do
+      rect = @rect.y(20)
+      rect.is_a?(CGRect).should == true
+      CGRectEqualToRect(rect, CGRectMake(10, 20, 50, 20)).should == true
+    end
+  end
+
+  describe "#y=" do
+    it "sets value" do
+      rect = CGRect.empty
+      rect.y = 20
+      rect.origin.y.should == 20
+    end
+  end
+
+  describe "#width" do
+    it "returns value when no args" do
+      @rect.width.should == 50
+    end
+
+    it "returns copy when has args" do
+      rect = @rect.width(20)
+      rect.is_a?(CGRect).should == true
+      CGRectEqualToRect(rect, CGRectMake(10, 100, 20, 20)).should == true
+    end
+  end
+
+  describe "#width=" do
+    it "sets value" do
+      rect = CGRect.empty
+      rect.width = 20
+      rect.size.width.should == 20
+    end
+  end
+
+  describe "#height" do
+    it "returns value when no args" do
+      @rect.height.should == 20
+    end
+
+    it "returns copy when has args" do
+      rect = @rect.height(50)
+      rect.is_a?(CGRect).should == true
+      CGRectEqualToRect(rect, CGRectMake(10, 100, 50, 50)).should == true
+    end
+  end
+
+  describe "#height=" do
+    it "sets value" do
+      rect = CGRect.empty
+      rect.height = 50
+      rect.size.height.should == 50
+    end
+  end
+
+  describe "#left" do
+    it "works" do
+      rect = CGRect.empty
+      rect = rect.left(20)
+      rect.origin.x.should == -20
+    end
+  end
+
+  describe "#right" do
+    it "works" do
+      rect = CGRect.empty.right(20)
+      rect.origin.x.should == 20
+    end
+  end
+
+  describe "#up" do
+    it "works" do
+      rect = CGRect.empty.up(20)
+      rect.origin.y.should == -20
+    end
+  end
+
+  describe "#down" do
+    it "works" do
+      rect = CGRect.empty.down(20)
+      rect.origin.y.should == 20
+    end
+  end
+
+  describe "#above" do
+    it "works with margins" do
+      rect = CGRect.make(height: 50).above(20)
+      rect.origin.y.should == -70
+    end
+
+    it "works without margins" do
+      rect = CGRect.make(height: 50).above
+      rect.origin.y.should == -50
+    end
+  end
+
+  describe "#below" do
+    it "works" do
+      rect = CGRect.make(height: 50).below(20)
+      rect.origin.y.should == 70
+    end
+  end
+
+  describe "#before" do
+    it "works" do
+      rect = CGRect.make(x: 50).before(20)
+      rect.origin.x.should == 30
+    end
+  end
+
+  describe "#before:width:" do
+    it "works" do
+      rect = CGRect.make(x: 50).before(20, width: 50)
+      rect.origin.x.should == -20
+    end
+  end
+
+  describe "#beside" do
+    it "works with margins" do
+      rect = CGRect.make(x: 50, width: 20).beside(10)
+      rect.origin.x.should == 80
+    end
+
+    it "works without margins" do
+      rect = CGRect.make(x: 50, width: 20).beside
+      rect.origin.x.should == 70
+    end
+  end
+
+  describe "#center" do
+    it "works" do
+      point = CGRect.make(width: 100, height: 100).center
+      point.is_a?(CGPoint).should == true
+      CGPointEqualToPoint(point, CGPointMake(50, 50)).should == true
+    end
+
+    it "works as relative" do
+      point = CGRect.make(x: 50, y: 50, width: 100, height: 100).center(true)
+      point.is_a?(CGPoint).should == true
+      CGPointEqualToPoint(point, CGPointMake(100, 100)).should == true
+    end
+  end
+
+  describe "#round" do
+    it "works" do
+      rect = CGRect.make(x: 10.5, y: 10.4, width: 100.025, height: 100.75)
+      CGRectEqualToRect(rect.round, CGRectMake(11, 10, 100, 101)).should == true
+    end
+  end
+
+  describe "#centered_in" do
+    it "works" do
+      outer_rect = CGRect.make(width: 100, height: 100)
+      inner_rect = CGRect.make(width: 50, height: 50)
+
+      centered_rect = inner_rect.centered_in(outer_rect)
+      CGRectEqualToRect(centered_rect, CGRectMake(25, 25, 50, 50)).should == true
+    end
+
+    it "works as relative" do
+      outer_rect = CGRect.make(x: 20, y: 30, width: 100, height: 100)
+      inner_rect = CGRect.make(width: 50, height: 50)
+
+      centered_rect = inner_rect.centered_in(outer_rect, true)
+      CGRectEqualToRect(centered_rect, CGRectMake(45, 55, 50, 50)).should == true
+    end
+  end
+
+  describe "#+" do
+    it "works with CGRect" do
+      _rect = CGRectMake(10, 100, 50, 20)
+      rect = (_rect + CGRectMake(0, 0, 50, 110))
+      CGRectEqualToRect(rect, CGRectMake(0, 0, 60, 120)).should == true
+    end
+
+    it "works with CGSize" do
+      size = CGSizeMake(50, 20)
+      rect = (@rect + size)
+      CGRectEqualToRect(rect, CGRectMake(10, 100, 100, 40)).should == true
+    end
+
+    it "works with CGPoint" do
+      point = CGPointMake(50, 20)
+      rect = (@rect + point)
+      CGRectEqualToRect(rect, CGRectMake(60, 120, 50, 20)).should == true
+    end
+
+    it "works with UIOffset" do
+      offset = UIOffsetMake(50, 20)
+      rect = (@rect + offset)
+      CGRectEqualToRect(rect, CGRectMake(60, 120, 50, 20)).should == true
+    end
+
+    it "works with UIEdgeInsets" do
+      inset = UIEdgeInsetsMake(10, 10, 10, 5)
+      rect = (@rect + inset)
+      CGRectEqualToRect(rect, CGRectMake(20, 110, 35, 0)).should == true
+    end
+  end
+
+  describe "#intersection_with" do
+    it "should work" do
+      lower_rect = CGRectMake(0, 0, 100, 100)
+      upper_rect = CGRectMake(10, 10, 100, 100)
+      rect = lower_rect.intersection_with(upper_rect)
+      CGRectEqualToRect(rect, CGRectMake(10, 10, 90, 90)).should == true
+    end
+  end
+
+  describe "#union_with" do
+    it "should work" do
+      lower_rect = CGRectMake(0, 0, 100, 100)
+      upper_rect = CGRectMake(10, 10, 100, 100)
+      rect = lower_rect.union_with(upper_rect)
+      CGRectEqualToRect(rect, CGRectMake(0, 0, 110, 110)).should == true
+    end
+  end
+
+  describe "#grow" do
+    it "should work with Numeric" do
+      rect = @rect.grow(10)
+      CGRectEqualToRect(rect, CGRectMake(0, 90, 70, 40)).should == true
+    end
+
+    it "should work with CGSize" do
+      rect = @rect.grow(CGSizeMake(10, 20))
+      CGRectEqualToRect(rect, CGRectMake(0, 80, 70, 60)).should == true
+    end
+  end
+
+  describe "#shrink" do
+    it "should work with Numeric" do
+      rect = @rect.shrink(10)
+      CGRectEqualToRect(rect, CGRectMake(20, 110, 30, 0)).should == true
+    end
+
+    it "should work with CGSize" do
+      rect = @rect.shrink(CGSizeMake(20, 10))
+      CGRectEqualToRect(rect, CGRectMake(30, 110, 10, 0)).should == true
+    end
+  end
+end

data/spec/cg_size_spec.rb

@@ -0,0 +1,60 @@
+describe "CGSize" do
+  before do
+    @size = CGSize.make(width: 100, height: 200)
+  end
+
+  describe ".make" do
+    it "should work with options" do
+      CGSizeEqualToSize(@size, CGSizeMake(100, 200)).should == true
+    end
+
+    it "should work with no options" do
+      CGSizeEqualToSize(CGSize.make, CGSizeMake(0, 0)).should == true
+    end
+  end
+
+  describe "#rect_at_point" do
+    it "should work" do
+      point = CGPointMake(20, 30)
+      @size.rect_at_point(point).should == CGRectMake(20, 30, 100, 200)
+    end
+  end
+
+  describe "#+" do
+    it "should work with CGSize" do
+      size = CGSizeMake(20, 30)
+      (@size + size).should == CGSizeMake(120, 230)
+    end
+
+    it "should work with CGPoint" do
+      point = CGPointMake(20, 30)
+      (@size + point).should == CGRectMake(20, 30, 100, 200)
+    end
+  end
+
+  describe "#infinite?" do
+    it "should return true" do
+      infinite = CGSize.infinite
+      infinite.infinite?.should == true
+    end
+  end
+
+  describe "#empty?" do
+    it "should return true" do
+      empty = CGSizeMake(0, 0)
+      empty.empty?.should == true
+    end
+  end
+
+  describe "#==?" do
+    it "should return true" do
+      size = CGSizeMake(100, 200)
+      @size.should == size
+    end
+
+    it "should return false" do
+      size = CGSizeMake(20, 10)
+      @size.should != size
+    end
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: geomotion
 version: !ruby/object:Gem::Version
-  version: 0.0.2
+  version: '0.1'
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-10-20 00:00:00.000000000 Z
+date: 2012-10-27 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
@@ -41,9 +41,13 @@ files:
 - Rakefile
 - app/app_delegate.rb
 - lib/geomotion.rb
+- lib/geomotion/cg_point.rb
 - lib/geomotion/cg_rect.rb
+- lib/geomotion/cg_size.rb
 - lib/geomotion/version.rb
-- spec/main_spec.rb
+- spec/cg_point_spec.rb
+- spec/cg_rect_spec.rb
+- spec/cg_size_spec.rb
 homepage: https://github.com/clayallsopp/geomotion
 licenses: []
 post_install_message: 
@@ -69,4 +73,6 @@ signing_key:
 specification_version: 3
 summary: A RubyMotion Geometry Wrapper
 test_files:
-- spec/main_spec.rb
+- spec/cg_point_spec.rb
+- spec/cg_rect_spec.rb
+- spec/cg_size_spec.rb

data/spec/main_spec.rb

@@ -1,36 +0,0 @@
-describe "CGRect" do
-  before do
-    @rect = CGRect.make(x: 10, y: 100, width: 50, height: 20)
-  end
-
-  it ".x, etc work" do
-    [@rect.x, @rect.y, @rect.width, @rect.height].should == [10, 100, 50, 20]
-  end
-
-  it "chaining works" do
-    rect = @rect.below(10).width(100).height(10)
-    [rect.x, rect.y, rect.width, rect.height].should == [10, 130, 100, 10]
-
-    [@rect.right(20).x, @rect.left(20).x, @rect.up(20).y, @rect.down(20).y].should == [30, -10, 80, 120]
-  end
-
-  it ".beside works" do
-    rect = @rect.beside(10)
-    [rect.x, rect.y, rect.width, rect.height].should == [70, 100, 50, 20]
-  end
-
-  it ".below works" do
-    @rect.below(10).y.should == 130
-  end
-
-  it "layout works" do
-    rect2 = CGRect.new [50, 50], [100, 100]
-    rect3 = CGRect.new [100, 200], [20, 20]
-
-    no_margins = CGRect.layout(@rect, above: rect2, right_of: rect3)
-    [no_margins.x, no_margins.y, no_margins.width, no_margins.height].should == [120, 30, 50, 20]
-
-    margins = CGRect.layout(@rect, above: rect2, right_of: rect3, margins: [0, 0, 10, 15])
-    [margins.x, margins.y, margins.width, margins.height].should == [135, 20, 50, 20]
-  end
-end