geomotion 0.12.3 → 0.13.0

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    geomotion (0.12.3)
+    geomotion (0.13.0)
 
 GEM
   remote: http://rubygems.org/

data/README.md

@@ -189,6 +189,26 @@ frame.top_center(true)  # => [15, 10]
 frame.bottom_right(true)  # => [20, 20]
 ```
 
+#### The great and powerful `apply` method
+
+All of the methods that return a new frame (`left, shrink, below` and friends)
+also accept a hash in which you can apply more changes.  You can accomplish the
+same thing using method chaining; this is an implementation detail that might
+also clean your code up by grouping changes.  And, of course, it can be used on
+its own as well.
+
+```ruby
+frame = CGRect.make(x: 10, y: 10, width:10, height: 10)
+frame.beside.width(20).down(10).height(20)
+# => [[20, 20], [20, 20]]
+# or, using the options hash
+frame.beside(width: 20, down: 10, height: 20)
+
+# there are some changes that don't have a corresponding method:
+frame.below(grow_width: 10, grow_up: 5)
+# => [[0, 15], [40, 25]]
+```
+
 ### CGSize
 
 ```ruby

data/lib/geomotion/cg_point.rb

@@ -1,4 +1,5 @@
 class CGPoint
+
   # CGPoint.make(x: 10, y: 30)
   def self.make(options = {})
     CGPoint.new(options[:x] || 0, options[:y] || 0)

data/lib/geomotion/cg_rect.rb

@@ -1,4 +1,5 @@
 class CGRect
+
   # 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]
@@ -100,7 +101,7 @@ class CGRect
   # getters/setters
   def x(setter = nil)
     if setter
-      return CGRect.new([setter, self.y], self.size)
+      return CGRect.new([setter, self.origin.y], self.size)
     end
     min_x
   end
@@ -111,7 +112,7 @@ class CGRect
 
   def y(setter = nil)
     if setter
-      return CGRect.new([self.x, setter], self.size)
+      return CGRect.new([self.origin.x, setter], self.size)
     end
     min_y
   end
@@ -122,7 +123,7 @@ class CGRect
 
   def width(setter = nil)
     if setter
-      return CGRect.new(self.origin, [setter, self.height])
+      return CGRect.new(self.origin, [setter, self.size.height])
     end
     CGRectGetWidth(self)
   end
@@ -133,7 +134,7 @@ class CGRect
 
   def height(setter = nil)
     if setter
-      return CGRect.new(self.origin, [self.width, setter])
+      return CGRect.new(self.origin, [self.size.width, setter])
     end
     CGRectGetHeight(self)
   end
@@ -142,70 +143,134 @@ class CGRect
     self.size.height = _height
   end
 
-  # modified rects
-  def left(dist = 0)
-    CGRect.new([self.x - dist, self.y], self.size)
-  end
-
-  def right(dist = 0)
-    CGRect.new([self.x + dist, self.y], self.size)
-  end
-
-  def up(dist = 0)
-    CGRect.new([self.x, self.y - dist], self.size)
-  end
-
-  def down(dist = 0)
-    CGRect.new([self.x, self.y + dist], self.size)
+  # most rect modifiers call this method in one way or another
+  def apply(options)
+    rect = CGRectStandardize(CGRect.new(self.origin, self.size))
+    options.each do |method, value|
+      case method
+      when :left
+        rect.origin.x -= value
+      when :right
+        rect.origin.x += value
+      when :up
+        rect.origin.y -= value
+      when :down
+        rect.origin.y += value
+      when :wider, :grow_right
+        rect.size.width += value
+      when :thinner, :shrink_left
+        rect.size.width -= value
+      when :taller, :grow_down
+        rect.size.height += value
+      when :shorter, :shrink_up
+        rect.size.height -= value
+      when :x
+        rect.origin.x = value
+      when :y
+        rect.origin.y = value
+      when :origin
+        rect.origin = value
+      when :width
+        rect.size.width = value
+      when :height
+        rect.size.height = value
+      when :size
+        rect.size = value
+      when :grow
+        rect = rect.grow(value)
+      when :grow_up
+        rect.size.height += value
+        rect.origin.y -= value
+      when :shrink_down
+        rect.size.height -= value
+        rect.origin.y += value
+      when :grow_left
+        rect.size.width += value
+        rect.origin.x -= value
+      when :shrink_right
+        rect.size.width -= value
+        rect.origin.x += value
+      when :grow_width
+        rect = rect.grow([value, 0])
+      when :grow_height
+        rect = rect.grow([0, value])
+      when :shrink
+        rect = rect.shrink(value)
+      when :shrink_width
+        rect = rect.shrink([value, 0])
+      when :shrink_height
+        rect = rect.shrink([0, value])
+      when :offset
+        rect = rect.offset(value)
+      else
+        raise "Unknow option #{method}"
+      end
+    end
+    return rect
   end
 
-  def wider(dist)
-    CGRect.new(self.origin, [self.width + dist, self.height])
+  # modified rects
+  def left(dist = 0, options={})
+    options[:left] = dist
+    self.apply(options)
   end
 
-  def thinner(dist)
-    CGRect.new(self.origin, [self.width - dist, self.height])
+  def right(dist = 0, options={})
+    options[:right] = dist
+    self.apply(options)
   end
 
-  def taller(dist)
-    CGRect.new(self.origin, [self.width, self.height + dist])
+  def up(dist = 0, options={})
+    options[:up] = dist
+    self.apply(options)
   end
 
-  def shorter(dist)
-    CGRect.new(self.origin, [self.width, self.height - dist])
+  def down(dist = 0, options={})
+    options[:down] = dist
+    self.apply(options)
   end
 
-  # adjacent rects
-  def above(margin = 0)
-    self.above(margin, height:self.height)
+  def wider(dist, options={})
+    options[:wider] = dist
+    self.apply(options)
   end
 
-  def above(margin, height:height)
-    CGRect.new([self.x, self.y - height - margin], [self.width, height])
+  def thinner(dist, options={})
+    options[:thinner] = dist
+    self.apply(options)
   end
 
-  def below(margin = 0)
-    self.below(margin, height:self.height)
+  def taller(dist, options={})
+    options[:taller] = dist
+    self.apply(options)
   end
 
-  def below(margin, height:height)
-    CGRect.new([self.x, self.y + self.height + margin], [self.width, height])
+  def shorter(dist, options={})
+    options[:shorter] = dist
+    self.apply(options)
   end
 
-  def before(margin = 0)
-    self.before(margin, width:self.width)
+  # adjacent rects
+  def above(margin = 0, options={})
+    height = options[:height] || self.size.height
+    options[:up] = height + margin
+    self.apply(options)
   end
 
-  def before(margin, width:width)
-    CGRect.new([self.x - width - margin, self.y], [width, self.height])
+  def below(margin = 0, options={})
+    options[:down] = self.size.height + margin
+    self.apply(options)
   end
 
-  def beside(margin = 0)
-    self.beside(margin, width: self.width)
+  def before(margin = 0, options={})
+    width = options[:width] || self.size.width
+    options[:left] = width + margin
+    self.apply(options)
   end
 
-  def beside(margin, width:width)
-    CGRect.new([self.x + self.width + margin, self.y], [width, self.height])
+  def beside(margin = 0, options={})
+    options[:right] = self.size.width + margin
+    self.apply(options)
   end
 
   # positions
@@ -220,7 +285,7 @@ private
 
 public
   def center(absolute = false)
-    cgrect_offset(absolute) + CGPoint.new(self.width / 2, self.height / 2)
+    cgrect_offset(absolute) + CGPoint.new(self.size.width / 2, self.size.height / 2)
   end
 
   def top_left(absolute = false)
@@ -228,36 +293,36 @@ public
   end
 
   def top_center(absolute = false)
-    cgrect_offset(absolute) + CGPoint.new(self.width / 2, 0)
+    cgrect_offset(absolute) + CGPoint.new(self.size.width / 2, 0)
   end
 
   def top_right(absolute = false)
-    cgrect_offset(absolute) + CGPoint.new(self.width, 0)
+    cgrect_offset(absolute) + CGPoint.new(self.size.width, 0)
   end
 
   def center_right(absolute = false)
-    cgrect_offset(absolute) + CGPoint.new(self.width, self.height / 2)
+    cgrect_offset(absolute) + CGPoint.new(self.size.width, self.size.height / 2)
   end
 
   def bottom_right(absolute = false)
-    cgrect_offset(absolute) + CGPoint.new(self.width, self.height)
+    cgrect_offset(absolute) + CGPoint.new(self.size.width, self.size.height)
   end
 
   def bottom_center(absolute = false)
-    cgrect_offset(absolute) + CGPoint.new(self.width / 2, self.height)
+    cgrect_offset(absolute) + CGPoint.new(self.size.width / 2, self.size.height)
   end
 
   def bottom_left(absolute = false)
-    cgrect_offset(absolute) + CGPoint.new(0, self.height)
+    cgrect_offset(absolute) + CGPoint.new(0, self.size.height)
   end
 
   def center_left(absolute = false)
-    cgrect_offset(absolute) + CGPoint.new(0, self.height / 2)
+    cgrect_offset(absolute) + CGPoint.new(0, self.size.height / 2)
   end
 
   # others
   def round
-    CGRect.new([self.x.round, self.y.round], [self.width.round, self.height.round])
+    CGRect.new([self.origin.x.round, self.origin.y.round], [self.size.width.round, self.size.height.round])
   end
 
   def centered_in(rect, absolute = false)
@@ -269,7 +334,7 @@ public
     when CGRect
       return self.union_with(other)
     when CGSize
-      return CGRect.new([self.x, self.y], [self.width + other.width, self.height + other.height])
+      return CGRect.new([self.origin.x, self.origin.y], [self.size.width + other.width, self.size.height + other.height])
     when CGPoint
       return self.offset(other.x, other.y)
     when UIOffset
@@ -319,18 +384,26 @@ public
     end
   end
 
-  def grow(size)
+  def grow(size, options=nil)
     if size.is_a? Numeric
       size = CGSize.new(size, size)
     end
-    CGRectInset(self, -size[0], -size[1])
+    rect = CGRectInset(self, -size[0], -size[1])
+    if options
+      return rect.apply(options)
+    end
+    return rect
   end
 
-  def shrink(size)
+  def shrink(size, options=nil)
     if size.is_a? Numeric
       size = CGSize.new(size, size)
     end
-    CGRectInset(self, size[0], size[1])
+    rect = CGRectInset(self, size[0], size[1])
+    if options
+      return rect.apply(options)
+    end
+    return rect
   end
 
   def empty?

data/lib/geomotion/version.rb

@@ -1,3 +1,3 @@
 module Geomotion
-  VERSION = "0.12.3"
+  VERSION = "0.13.0"
 end

data/spec/cg_rect_spec.rb

@@ -158,7 +158,7 @@ describe "CGRect" do
     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
+      rect.should == CGRectMake(20, 100, 50, 20)
     end
   end
 
@@ -183,7 +183,7 @@ describe "CGRect" do
     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
+      rect.should == CGRectMake(10, 20, 50, 20)
     end
   end
 
@@ -206,7 +206,7 @@ describe "CGRect" do
     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
+      rect.should == CGRectMake(10, 100, 20, 20)
     end
   end
 
@@ -229,7 +229,7 @@ describe "CGRect" do
     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
+      rect.should == CGRectMake(10, 100, 50, 50)
     end
   end
 
@@ -608,50 +608,50 @@ describe "CGRect" 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
+      rect.should == CGRectMake(0, 0, 60, 120)
     end
 
     it "works with CGSize" do
       size = CGSizeMake(50, 20)
       rect = (@rect + size)
-      CGRectEqualToRect(rect, CGRectMake(10, 100, 100, 40)).should == true
+      rect.should == CGRectMake(10, 100, 100, 40)
     end
 
     it "works with CGPoint" do
       point = CGPointMake(50, 20)
       rect = (@rect + point)
-      CGRectEqualToRect(rect, CGRectMake(60, 120, 50, 20)).should == true
+      rect.should == CGRectMake(60, 120, 50, 20)
     end
 
     it "works with UIOffset" do
       offset = UIOffsetMake(50, 20)
       rect = (@rect + offset)
-      CGRectEqualToRect(rect, CGRectMake(60, 120, 50, 20)).should == true
+      rect.should == CGRectMake(60, 120, 50, 20)
     end
 
     it "works with UIEdgeInsets" do
       insets = UIEdgeInsetsMake(10, 10, 10, 5)
       rect = (@rect + insets)
-      CGRectEqualToRect(rect, CGRectMake(20, 110, 35, 0)).should == true
+      rect.should == CGRectMake(20, 110, 35, 0)
     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
+      rect.should == CGRectMake(60, 120, 50, 20)
     end
 
     it "works with CGPoint" do
       point = CGPointMake(50, 20)
       rect = @rect.offset(point)
-      CGRectEqualToRect(rect, CGRectMake(60, 120, 50, 20)).should == true
+      rect.should == CGRectMake(60, 120, 50, 20)
     end
 
     it "works with UIOffset" do
       offset = UIOffsetMake(50, 20)
       rect = @rect.offset(offset)
-      CGRectEqualToRect(rect, CGRectMake(60, 120, 50, 20)).should == true
+      rect.should == CGRectMake(60, 120, 50, 20)
     end
   end
 
@@ -659,7 +659,7 @@ describe "CGRect" 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
+      rect.should == CGRectMake(20, 110, 35, 0)
     end
   end
 
@@ -686,7 +686,7 @@ describe "CGRect" 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
+      rect.should == CGRectMake(10, 10, 90, 90)
     end
   end
 
@@ -695,36 +695,166 @@ describe "CGRect" 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
+      rect.should == CGRectMake(0, 0, 110, 110)
     end
   end
 
   describe "#grow" do
     it "should work with Numeric" do
       rect = @rect.grow(10)
-      CGRectEqualToRect(rect, CGRectMake(0, 90, 70, 40)).should == true
+      rect.should == CGRectMake(0, 90, 70, 40)
     end
 
     it "should work with CGSize" do
       rect = @rect.grow(CGSizeMake(10, 20))
-      CGRectEqualToRect(rect, CGRectMake(0, 80, 70, 60)).should == true
+      rect.should == CGRectMake(0, 80, 70, 60)
     end
   end
 
   describe "#shrink" do
     it "should work with Numeric" do
       rect = @rect.shrink(10)
-      CGRectEqualToRect(rect, CGRectMake(20, 110, 30, 0)).should == true
+      rect.should == CGRectMake(20, 110, 30, 0)
     end
 
     it "should work with CGSize" do
       rect = @rect.shrink(CGSizeMake(20, 10))
-      CGRectEqualToRect(rect, CGRectMake(30, 110, 10, 0)).should == true
+      rect.should == CGRectMake(30, 110, 10, 0)
     end
 
     it "should work with Array" do
       rect = @rect.shrink([20, 10])
-      CGRectEqualToRect(rect, CGRectMake(30, 110, 10, 0)).should == true
+      rect.should == CGRectMake(30, 110, 10, 0)
     end
   end
+
+  describe "#apply" do
+
+    it "should support :left" do
+      rect = @rect.apply(left: 10)
+      rect.should == CGRectMake(0, 100, 50, 20)
+    end
+
+    it "should support :right" do
+      rect = @rect.apply(right: 10)
+      rect.should == CGRectMake(20, 100, 50, 20)
+    end
+
+    it "should support :up" do
+      rect = @rect.apply(up: 10)
+      rect.should == CGRectMake(10, 90, 50, 20)
+    end
+
+    it "should support :down" do
+      rect = @rect.apply(down: 10)
+      rect.should == CGRectMake(10, 110, 50, 20)
+    end
+
+    it "should support :wider" do
+      rect = @rect.apply(wider: 10)
+      rect.should == CGRectMake(10, 100, 60, 20)
+    end
+
+    it "should support :thinner" do
+      rect = @rect.apply(thinner: 10)
+      rect.should == CGRectMake(10, 100, 40, 20)
+    end
+
+    it "should support :taller" do
+      rect = @rect.apply(taller: 10)
+      rect.should == CGRectMake(10, 100, 50, 30)
+    end
+
+    it "should support :shorter" do
+      rect = @rect.apply(shorter: 10)
+      rect.should == CGRectMake(10, 100, 50, 10)
+    end
+
+    it "should support :x" do
+      rect = @rect.apply(x: 11)
+      rect.should == CGRectMake(11, 100, 50, 20)
+    end
+
+    it "should support :y" do
+      rect = @rect.apply(y: 10)
+      rect.should == CGRectMake(10, 10, 50, 20)
+    end
+
+    it "should support :origin" do
+      rect = @rect.apply(origin: [11, 10])
+      rect.should == CGRectMake(11, 10, 50, 20)
+    end
+
+    it "should support :width" do
+      rect = @rect.apply(width: 10)
+      rect.should == CGRectMake(10, 100, 10, 20)
+    end
+
+    it "should support :height" do
+      rect = @rect.apply(height: 10)
+      rect.should == CGRectMake(10, 100, 50, 10)
+    end
+
+    it "should support :size" do
+      rect = @rect.apply(size: [10, 10])
+      rect.should == CGRectMake(10, 100, 10, 10)
+    end
+
+    it "should support :grow" do
+      rect = @rect.apply(grow: 10)
+      rect.should == CGRectMake(0, 90, 70, 40)
+    end
+
+    it "should support :grow_up" do
+      rect = @rect.apply(grow_up: 10)
+      rect.should == CGRectMake(10, 90, 50, 30)
+    end
+
+    it "should support :shrink_down" do
+      rect = @rect.apply(shrink_down: 10)
+      rect.should == CGRectMake(10, 110, 50, 10)
+    end
+
+    it "should support :grow_left" do
+      rect = @rect.apply(grow_left: 10)
+      rect.should == CGRectMake(0, 100, 60, 20)
+    end
+
+    it "should support :shrink_right" do
+      rect = @rect.apply(shrink_right: 10)
+      rect.should == CGRectMake(20, 100, 40, 20)
+    end
+
+    it "should support :grow_width" do
+      rect = @rect.apply(grow_width: 10)
+      rect.should == CGRectMake(0, 100, 70, 20)
+    end
+
+    it "should support :grow_height" do
+      rect = @rect.apply(grow_height: 10)
+      rect.should == CGRectMake(10, 90, 50, 40)
+    end
+
+    it "should support :shrink" do
+      rect = @rect.apply(shrink: 10)
+      rect.should == CGRectMake(20, 110, 30, 0)
+    end
+
+    it "should support :shrink_width" do
+      rect = @rect.apply(shrink_width: 10)
+      rect.should == CGRectMake(20, 100, 30, 20)
+    end
+
+    it "should support :shrink_height" do
+      rect = @rect.apply(shrink_height: 10)
+      rect.should == CGRectMake(10, 110, 50, 0)
+    end
+
+    it "should support :offset" do
+      rect = @rect.apply(offset: [10, 10])
+      rect.should == CGRectMake(20, 110, 50, 20)
+    end
+
+  end
+
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: geomotion
 version: !ruby/object:Gem::Version
-  version: 0.12.3
+  version: 0.13.0
   prerelease: 
 platform: ruby
 authors:
@@ -10,7 +10,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-08-09 00:00:00.000000000 Z
+date: 2013-10-05 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake