geomotion 0.1 → 0.5

data/README.md

@@ -1,4 +1,4 @@
-# Geomotion
+# Geomotion for [RubyMotion](http://rubymotion.com)
 
 iOS Geometry in idiomatic Ruby. Exhaustively tested. What's not to love?
 
@@ -26,35 +26,38 @@ rect.center(true)
 => CGPoint(35, 110) # center as frame
 
 # Operator Overloading
+-rect
+=> CGRect(-10, -100, -50, -20)
+
 rect + CGRect.make(x: 9, y: 99, width: 10, height: 10)
 => CGRect(9, 99, 50, 20) # == union of rects
 
-rect + CGSize.new(11, 1)
+rect + CGSize.make(width: 11, height: 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 + CGPoint.make(x: 10, y: 10)
+=> CGRect(20, 110, 50, 20)
 
 rect + UIOffsetMake(10, 10)
-=> CGRect.new(20, 110, 50, 20)
+=> CGRect(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)
+rect.union_with CGRect.make(x: 9, y: 99, width: 10, height: 10)
 => CGRect(9, 99, 50, 20)
 
-rect.intersection_with CGRect.new(9, 99, 10, 10)
-=> CGRect.new(10, 100, 10, 10)
+rect.intersection_with CGRect.make(x: 9, y: 99, width: 10, height: 10)
+=> CGRect(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.grow(CGSize.make(width: 10, height: 20))
+=> CGRect(5, 90, 60, 40)
 
 rect.shrink(10)
-=> CGRect.new(15, 105, 40, 10)
+=> CGRect(15, 105, 40, 10)
 
 # Powerful layout adjustments with chainable methods
 view = UIView.alloc.initWithFrame rect.below.width(100).height(10)
@@ -73,14 +76,14 @@ rect = CGRect.make(x: 10, y: 100, width: 50, height: 20)
 # Layout "above" and "before" rectangles
 # (default offset is the rectangle's width or height)
 rect.before(5)
-=> CGRect.new(-45, 100, 50, 20)
+=> CGRect(-45, 100, 50, 20)
 rect.before(5, width:20)
-=> CGRect.new(-15, 100, 20, 20)
+=> CGRect(-15, 100, 20, 20)
 
 rect.above(5)
-=> CGRect.new(10, 75, 50, 20)
+=> CGRect(10, 75, 50, 20)
 rect.above(5, height:10)
-=> CGRect.new(10, 85, 50, 10)
+=> CGRect(10, 85, 50, 10)
 
 # Layout a rect relative to others
 rect2 = CGRect.make(x: 50, y: 50, width: 100, height: 100)
@@ -108,6 +111,9 @@ size_zero.empty?
 => true
 
 # Operator Overloading
+-size
+=> CGSize(-50, -20)
+
 size + CGSize.make(width: 100, height: 50)
 => CGSize(150, 70)
 
@@ -126,6 +132,9 @@ size.rect_at_point CGPoint.make(x: 10, y: 30)
 point = CGPoint.make(x: 10, y: 100)
 
 # Operator Overloading
+-point
+=> CGPoint(-10, -100)
+
 point + CGPoint.make(x: 20, y: 40)
 => CGPoint(30, 140)
 

data/lib/geomotion/cg_point.rb

@@ -6,7 +6,7 @@ class CGPoint
 
   # 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(size)  # => 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)
@@ -33,4 +33,16 @@ class CGPoint
     point.is_a?(CGPoint) && CGPointEqualToPoint(self, point)
   end
 
+  def -@
+    CGPoint.new(-self.x, -self.y)
+  end
+
+  def -(other)
+    self.+(-other)
+  end
+
+  def inspect
+    "#{self.class.name}(#{self.x}, #{self.y})"
+  end
+
 end

data/lib/geomotion/cg_rect.rb

@@ -1,29 +1,48 @@
 class CGRect
-  # CGRect.make(x: 10, y: 30)
+  # CGRect.make  # default rect: {origin: {x: 0, y: 0}, size: {width:0, height:0}}
+  #              # aka CGRectZero
+  # CGRect.make(x: 10, y: 30)  # default size: [0, 0]
   # CGRect.make(x: 10, y: 30, width:100, height: 20)
+  #
+  # point = CGPoint.make(x: 10, y: 30)
+  # size = CGSize.make(width: 100, height: 20)
+  # CGRect.make(origin: point, size: size)
   def self.make(options = {})
     if options[:origin]
-      options[:x] = options[:origin].x
-      options[:y] = options[:origin].y
+      x = options[:origin].x
+      y = options[:origin].y
+    else
+      x = options[:x] || 0
+      y = options[:y] || 0
     end
     if options[:size]
-      options[:width] = options[:size].width
-      options[:height] = options[:size].height
+      w = options[:size].width
+      h = options[:size].height
+    else
+      w = options[:width] || 0
+      h = options[:height] || 0
     end
-    CGRect.new([options[:x] || 0, options[:y] || 0], [options[:width] || 0, options[:height] || 0])
+    self.new([x, y], [w, h])
   end
 
   def self.empty
-    # Don't return CGRectZero; can be mutated
-    CGRect.make
+    # Don't just return CGRectZero; can be mutated
+    CGRectZero.dup
   end
 
   def self.null
-    CGRectNull
+    # Don't just return CGRectNull; can be mutated
+    CGRectNull.dup
   end
 
   def self.infinite
-    self.new([0, 0], CGSize.infinite)
+    # This actually returns the not-very-infinite value of:
+    # [[-1.7014114289565e+38, -1.7014114289565e+38], [3.402822857913e+38, 3.402822857913e+38]]
+    # originally this method returned [[-Infinity, -Infinity], [Infinity, Infinity]],
+    # but that rect ended up returning `false` for any point in the method
+    # CGRect.infinite.contains?(point).  CGRectInfinite returns `true` for any
+    # (sensible) point, so we'll go with that instead
+    CGRectInfinite.dup
   end
 
   # OPTIONS: [:above, :below, :left_of, :right_of, :margins]
@@ -31,11 +50,11 @@ class CGRect
   # EX CGRect.layout(rect1, above: rect2, left_of: rect3, margins: [0, 10, 20, 0])
   def self.layout(rect1, options)
     if options.empty?
-      p "No options provided in CGRect.layout"
+      p "No options provided in #{self.class}.layout"
       return rect1
     end
 
-    rect = CGRect.new
+    rect = self.new
     rect.size = rect1.size
 
     options[:margins] ||= []
@@ -53,11 +72,29 @@ class CGRect
     rect
   end
 
+  # bounds
+  def min_x
+    CGRectGetMinX(self)
+  end
+
+  def max_x
+    CGRectGetMaxX(self)
+  end
+
+  def min_y
+    CGRectGetMinY(self)
+  end
+
+  def max_y
+    CGRectGetMaxY(self)
+  end
+
+  # getters/setters
   def x(setter = nil)
     if setter
       return CGRect.new([setter, self.y], self.size)
     end
-    self.origin.x
+    min_x
   end
 
   def x=(_x)
@@ -68,7 +105,7 @@ class CGRect
     if setter
       return CGRect.new([self.x, setter], self.size)
     end
-    self.origin.y
+    min_y
   end
 
   def y=(_y)
@@ -79,7 +116,7 @@ class CGRect
     if setter
       return CGRect.new(self.origin, [setter, self.height])
     end
-    self.size.width
+    CGRectGetWidth(self)
   end
 
   def width=(_width)
@@ -90,13 +127,14 @@ class CGRect
     if setter
       return CGRect.new(self.origin, [self.width, setter])
     end
-    self.size.height
+    CGRectGetHeight(self)
   end
 
   def height=(_height)
     self.size.height = _height
   end
 
+  # modified rects
   def left(dist = 0)
     CGRect.new([self.x - dist, self.y], self.size)
   end
@@ -113,6 +151,23 @@ class CGRect
     CGRect.new([self.x, self.y + dist], self.size)
   end
 
+  def wider(dist)
+    CGRect.new(self.origin, [self.width + dist, self.height])
+  end
+
+  def thinner(dist)
+    CGRect.new(self.origin, [self.width - dist, self.height])
+  end
+
+  def taller(dist)
+    CGRect.new(self.origin, [self.width, self.height + dist])
+  end
+
+  def shorter(dist)
+    CGRect.new(self.origin, [self.width, self.height - dist])
+  end
+
+  # adjacent rects
   def above(margin = 0)
     self.above(margin, height:self.height)
   end
@@ -134,24 +189,43 @@ class CGRect
   end
 
   def beside(margin = 0)
-    CGRect.new([self.x + self.width + margin, self.y], self.size)
+    self.beside(margin, width: self.width)
   end
 
-  def center(relative = false)
-    offset_x = relative ? self.x : 0
-    offset_y = relative ? self.y : 0
+  def beside(margin, width:width)
+    CGRect.new([self.x + self.width + margin, self.y], [width, self.height])
+  end
+
+  # locations
+  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)
   end
 
+  def top_left
+    CGPoint.new(CGRectGetMinX(self), CGRectGetMinY(self))
+  end
+
+  def top_right
+    CGPoint.new(CGRectGetMaxX(self), CGRectGetMinY(self))
+  end
+
+  def bottom_left
+    CGPoint.new(CGRectGetMinX(self), CGRectGetMaxY(self))
+  end
+
+  def bottom_right
+    CGPoint.new(CGRectGetMaxX(self), CGRectGetMaxY(self))
+  end
+
+  # others
   def round
     CGRect.new([self.x.round, self.y.round], [self.width.round, self.height.round])
   end
 
-  def centered_in(rect, relative = false)
-    offset_x = relative ? rect.x : 0
-    offset_y = relative ? rect.y : 0
-    CGRect.new([offset_x + ((rect.width - self.width) / 2),
-                offset_y + ((rect.height - self.height) / 2)], self.size)
+  def centered_in(rect, absolute = false)
+    self.size.centered_in(rect, absolute)
   end
 
   def +(other)
@@ -196,7 +270,7 @@ class CGRect
   end
 
   def infinite?
-    self.size.infinite?
+    self.size.infinite? || CGRectEqualToRect(self, CGRectInfinite)
   end
 
   def null?
@@ -208,7 +282,7 @@ class CGRect
     when CGRect
       CGRectIntersectsRect(self, rect)
     else
-      super
+      super  # raises an error
     end
   end
 
@@ -219,11 +293,24 @@ class CGRect
     when CGRect
       CGRectContainsRect(self, rect_or_point)
     else
-      super
+      super  # raises an error
     end
   end
 
   def ==(rect)
     rect.is_a?(CGRect) && CGRectEqualToRect(self, rect)
   end
+
+  def -@
+    CGRect.new(-self.origin, -self.size)
+  end
+
+  def -(other)
+    self.+(-other)
+  end
+
+  def inspect
+    "#{self.class.name}([#{self.origin.x}, #{self.origin.y}], [#{self.size.width}, #{self.size.height}])"
+  end
+
 end

data/lib/geomotion/cg_size.rb

@@ -9,6 +9,10 @@ class CGSize
     CGSizeMake(infinity, infinity)
   end
 
+  def self.empty
+    CGSizeZero.dup
+  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])
@@ -17,6 +21,13 @@ class CGSize
     CGRect.new(point, [self.width, self.height])
   end
 
+  def centered_in(rect, absolute = false)
+    offset_x = absolute ? rect.x : 0
+    offset_y = absolute ? rect.y : 0
+    CGRect.new([offset_x + ((rect.width - self.width) / 2),
+                offset_y + ((rect.height - self.height) / 2)], self)
+  end
+
   def +(other)
     case other
     when CGSize
@@ -38,4 +49,17 @@ class CGSize
   def ==(size)
     size.is_a?(CGSize) && CGSizeEqualToSize(self, size)
   end
+
+  def -@
+    CGSize.new(-self.width, -self.height)
+  end
+
+  def -(other)
+    self.+(-other)
+  end
+
+  def inspect
+    "#{self.class.name}(#{self.width}, #{self.height})"
+  end
+
 end

data/lib/geomotion/version.rb

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

data/spec/cg_point_spec.rb

@@ -32,6 +32,20 @@ describe "CGPoint" do
     end
   end
 
+  describe "#- (unary)" do
+    it "should work" do
+      point = CGPoint.make(x: 100, y: 200)
+      (-point).should == CGPoint.new(-100, -200)
+    end
+  end
+
+  describe "#- (binary)" do
+    it "should work" do
+      point = CGPoint.make(x: 100, y: 200)
+      (point - point).should == CGPoint.new(0, 0)
+    end
+  end
+
   describe "#inside?" do
     it "should return true" do
       rect = CGRectMake(0, 0, 100, 100)

data/spec/cg_rect_spec.rb

@@ -24,11 +24,19 @@ describe "CGRect" do
     it "should work" do
       CGRectIsEmpty(CGRect.empty).should == true
     end
+
+    it "should not be mutable" do
+      f = CGRect.empty
+      f.width = 10
+      f.height = 10
+      f.x = 10
+      f.y = 10
+      CGRectIsEmpty(CGRect.empty).should == true
+    end
   end
 
   describe "#empty?" do
     it "should work" do
-      p "ZERO1 #{CGRectZero.inspect}"
       CGRectZero.empty?.should == true
     end
   end
@@ -37,26 +45,44 @@ describe "CGRect" do
     it "should work" do
       CGRectIsNull(CGRect.null).should == true
     end
+
+    it "should not be mutable" do
+      f = CGRect.null
+      f.width = 10
+      f.height = 10
+      f.x = 10
+      f.y = 10
+      CGRectIsNull(CGRect.null).should == true
+    end
   end
 
   describe "#null?" do
     it "should work" do
       CGRectNull.null?.should == true
+      CGRect.null.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
+      CGRect.infinite.infinite?.should == true
+    end
+
+    it "should not be mutable" do
+      f = CGRect.infinite
+      f.width = 10
+      f.height = 10
+      f.x = 10
+      f.y = 10
+      CGRect.infinite.infinite?.should == true
     end
   end
-=end
 
   describe "#infinite?" do
     it "should work" do
       CGRect.infinite.infinite?.should == true
+      CGRectInfinite.infinite?.should == true
     end
   end
 
@@ -221,6 +247,34 @@ describe "CGRect" do
     end
   end
 
+  describe "#wider" do
+    it "works" do
+      rect = CGRect.empty.wider(20)
+      rect.size.width.should == 20
+    end
+  end
+
+  describe "#thinner" do
+    it "works" do
+      rect = CGRect.empty.thinner(20)
+      rect.size.width.should == -20
+    end
+  end
+
+  describe "#taller" do
+    it "works" do
+      rect = CGRect.empty.taller(20)
+      rect.size.height.should == 20
+    end
+  end
+
+  describe "#shorter" do
+    it "works" do
+      rect = CGRect.empty.shorter(20)
+      rect.size.height.should == -20
+    end
+  end
+
   describe "#above" do
     it "works with margins" do
       rect = CGRect.make(height: 50).above(20)
@@ -266,6 +320,50 @@ describe "CGRect" do
     end
   end
 
+  describe "#beside:width:" do
+    it "works" do
+      rect = CGRect.make(x: 50, width: 20).beside(10, width: 30)
+      rect.origin.x.should == 80
+      rect.size.width.should == 30
+    end
+  end
+
+  describe "#top_left" do
+    it "works" 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(10, 20)).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(10, 220)).should == true
+    end
+  end
+
+  describe "#top_right" do
+    it "works" 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(110, 20)).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(110, 220)).should == true
+    end
+  end
+
   describe "#center" do
     it "works" do
       point = CGRect.make(width: 100, height: 100).center
@@ -305,6 +403,20 @@ describe "CGRect" do
     end
   end
 
+  describe "#- (unary)" do
+    it "should work" do
+      rect = CGRect.make(x: 10, y:10, width: 100, height: 200)
+      (-rect).should == CGRect.new([-10, -10], [-100, -200])
+    end
+  end
+
+  describe "#- (binary)" do
+    it "should work" do
+      rect = CGRect.make(x: 10, y:10, width: 100, height: 200)
+      (rect - rect).should == CGRect.new([-110, -210], [220, 420])
+    end
+  end
+
   describe "#+" do
     it "works with CGRect" do
       _rect = CGRectMake(10, 100, 50, 20)

data/spec/cg_size_spec.rb

@@ -20,6 +20,20 @@ describe "CGSize" do
     end
   end
 
+  describe "#- (unary)" do
+    it "should work" do
+      size = CGSize.make(width: 100, height: 200)
+      (-size).should == CGSize.new(-100, -200)
+    end
+  end
+
+  describe "#- (binary)" do
+    it "should work" do
+      size = CGSize.make(width: 100, height: 200)
+      (size - size).should == CGSize.new(0, 0)
+    end
+  end
+
   describe "#+" do
     it "should work with CGSize" do
       size = CGSizeMake(20, 30)
@@ -39,6 +53,19 @@ describe "CGSize" do
     end
   end
 
+  describe ".empty" do
+    it "should work" do
+      CGRectIsEmpty(CGSize.empty.rect_at_point([0, 0])).should == true
+    end
+
+    it "should not be mutable" do
+      f = CGSize.empty
+      f.width = 10
+      f.height = 10
+      CGRectIsEmpty(CGSize.empty.rect_at_point([0, 0])).should == true
+    end
+  end
+
   describe "#empty?" do
     it "should return true" do
       empty = CGSizeMake(0, 0)
@@ -57,4 +84,23 @@ describe "CGSize" do
       @size.should != size
     end
   end
+
+  describe "#centered_in" do
+    it "works" do
+      outer_rect = CGRect.make(width: 100, height: 100)
+      inner_size = CGSize.make(width: 50, height: 50)
+
+      centered_rect = inner_size.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_size = CGSize.make(width: 50, height: 50)
+
+      centered_rect = inner_size.centered_in(outer_rect, true)
+      CGRectEqualToRect(centered_rect, CGRectMake(45, 55, 50, 50)).should == true
+    end
+  end
+
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: geomotion
 version: !ruby/object:Gem::Version
-  version: '0.1'
+  version: '0.5'
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-10-27 00:00:00.000000000 Z
+date: 2012-12-27 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake