sugarcube 0.11.3 → 0.12

data/lib/sugarcube/uitableview.rb

@@ -1,11 +1,11 @@
 class UITableView
   class << self
 
-    def plain(frame=[[0, 0], [320, 480]])
+    def plain(frame=[[0, 0], [0, 0]])
       UITableView.alloc.initWithFrame(frame, style: :plain.uitableviewstyle)
     end
 
-    def grouped(frame=[[0, 0], [320, 480]])
+    def grouped(frame=[[0, 0], [0, 0]])
       UITableView.alloc.initWithFrame(frame, style: :grouped.uitableviewstyle)
     end
 

data/lib/sugarcube/uiview.rb

@@ -22,6 +22,19 @@ class UIView
     return found
   end
 
+  # returns the nearest nextResponder instance that is a UIViewController. Goes
+  # up the responder chain until the nextResponder is a UIViewController
+  # subclass, or returns nil if none is found.
+  def controller
+    if nextResponder && nextResponder.is_a?(UIViewController)
+      nextResponder
+    elsif nextResponder
+      nextResponder.controller
+    else
+      nil
+    end
+  end
+
   def <<(view)
     self.addSubview view
     return self
@@ -37,20 +50,10 @@ class UIView
     self
   end
 
-  def _after_proc(after)
-    after ? proc  { |finished|
-                    if after.arity == 0
-                      after.call
-                    else
-                      after.call(finished)
-                    end
-                  } : nil
-  end
-
   # If options is a Numeric, it is used as the duration.  Otherwise, duration
   # is an option, and defaults to 0.3.  All the transition methods work this
   # way.
-  def fade_out(options={}, &after)
+  def self.animate(options={}, &animations)
     if options.is_a? Numeric
       duration = options
       options = {}
@@ -58,25 +61,28 @@ class UIView
       duration = options[:duration] || 0.3
     end
 
-    after = _after_proc(after)
+    after_animations = options[:after]
+    if after_animations
+      if after_animations.arity == 0
+        after_adjusted = proc { |finished| after_animations.call }
+      else
+        after_adjusted = proc { |finished| after_animations.call(finished) }
+      end
+    else
+      after_adjusted = nil
+    end
 
-    UIView.animateWithDuration(duration,
+    UIView.animateWithDuration( duration,
                          delay: options[:delay] || 0,
                        options: options[:options] || UIViewAnimationOptionCurveEaseInOut,
-                    animations: proc{
-                                  self.layer.opacity = options[:opacity] || 0
-
-                                  if assign = options[:assign]
-                                    assign.each_pair do |key, value|
-                                      self.send("#{key}=", value)
-                                    end
-                                  end
-                                }, completion:after
+                    animations: proc,
+                    completion: after_adjusted
                               )
-    self
+    nil
   end
 
-  def fade_in(options={}, &after)
+  # Same as UIView##animate, but acts on self
+  def animate(options={}, &animations)
     if options.is_a? Numeric
       duration = options
       options = {}
@@ -84,36 +90,67 @@ class UIView
       duration = options[:duration] || 0.3
     end
 
-    options[:opacity] = 1.0
-    fade_out(options, &after)
+    assign = options[:assign] || {}
+
+    UIView.animate(options) {
+      animations.call if animations
+
+      assign.each_pair do |key, value|
+        self.send("#{key}=", value)
+      end
+    }
+    self
+  end
+
+  # Changes the layer opacity.
+  def fade(options={}, &after)
+    if options.is_a? Numeric
+      options = { opacity: options }
+    end
+
+    options[:after] ||= after
+
+    animate(options) {
+      self.layer.opacity = options[:opacity]
+    }
+  end
+
+  # Changes the layer opacity to 0.
+  # @see #fade
+  def fade_out(options={}, &after)
+    if options.is_a? Numeric
+      options = { duration: options }
+    end
+
+    options[:opacity] ||= 0.0
+
+    fade(options, &after)
+  end
+
+  # Changes the layer opacity to 1.
+  # @see #fade
+  def fade_in(options={}, &after)
+    if options.is_a? Numeric
+      options = { duration: options }
+    end
+
+    options[:opacity] ||= 1.0
+
+    fade(options, &after)
   end
 
   def move_to(position, options={}, &after)
     if options.is_a? Numeric
-      duration = options
-      options = {}
-    else
-      duration = options[:duration] || 0.3
+      options = { duration: options }
     end
 
-    after = _after_proc(after)
+    options[:after] ||= after
 
-    UIView.animateWithDuration(duration,
-                         delay: options[:delay] || 0,
-                       options: options[:options] || UIViewAnimationOptionCurveEaseInOut,
-                    animations: proc{
-                                  f = self.frame
-                                  f.origin = SugarCube::CoreGraphics::Point(position)
-                                  self.frame = f
-
-                                  if assign = options[:assign]
-                                    assign.each_pair do |key, value|
-                                      self.send("#{key}=", value)
-                                    end
-                                  end
-                                }, completion:after
-                              )
-    self
+    animate(options) {
+      f = self.frame
+      f.origin = SugarCube::CoreGraphics::Point(position)
+      self.frame = f
+    }
   end
 
   def delta_to(delta, options={}, &after)
@@ -158,12 +195,16 @@ class UIView
 
     offset = options[:offset] || 8
     repeat = options[:repeat] || 3
-    duration /= repeat
+    if repeat == Float::INFINITY
+      duration = 0.1
+    else
+      duration /= repeat
+    end
     keypath = options[:keypath] || 'transform.translation.x'
 
-    origin = 0
-    left = -offset
-    right = +offset
+    origin = options[:origin] || 0
+    left = origin - offset
+    right = origin + offset
 
     animation = CAKeyframeAnimation.animationWithKeyPath(keypath)
     animation.duration = duration

data/lib/sugarcube/uiviewcontroller.rb

@@ -2,6 +2,7 @@ class UIViewController
 
   def push(view_controller)
     self.addChildViewController(view_controller)
+    view_controller.didMoveToParentViewController(self)
     self
   end
 

data/lib/sugarcube/version.rb

@@ -1,3 +1,3 @@
 module SugarCube
-  Version = '0.11.3'
+  Version = '0.12'
 end

data/spec/core_graphics_spec.rb

@@ -0,0 +1,304 @@
+describe "SugarCube::CoreGraphics" do
+  describe 'Point()' do
+    it 'should accept 1 argument: a CGPoint' do
+      cgpoint = CGPoint.new(1, 2)
+      p = Point(cgpoint)
+      p.x.should == 1
+      p.y.should == 2
+      CGPointEqualToPoint(p, cgpoint).should == true
+    end
+
+    it 'should accept 1 argument: a CGSize' do
+      cgsize = CGSize.new(1, 2)
+      p = Point(cgsize)
+      p.x.should == 1
+      p.y.should == 2
+      CGPointEqualToPoint(p, CGPoint.new(cgsize.width, cgsize.height)).should == true
+    end
+
+    it 'should accept 1 argument: a UIOffset' do
+      uioffset = UIOffset.new(1, 2)
+      p = Point(uioffset)
+      p.x.should == 1
+      p.y.should == 2
+      CGPointEqualToPoint(p, CGPoint.new(uioffset.horizontal, uioffset.vertical)).should == true
+    end
+
+    it 'should accept 1 argument: an Array' do
+      array = [1, 2]
+      p = Point(array)
+      p.x.should == 1
+      p.y.should == 2
+      CGPointEqualToPoint(p, CGPoint.new(array[0], array[1])).should == true
+    end
+
+    it 'should accept 2 arguments: two numbers' do
+      args = [1, 2]
+      p = Point(*args)
+      p.x.should == 1
+      p.y.should == 2
+      CGPointEqualToPoint(p, CGPoint.new(args[0], args[1])).should == true
+    end
+  end
+
+  describe 'Size()' do
+    it 'should accept 1 argument: a CGPoint' do
+      cgpoint = CGPoint.new(1, 2)
+      s = Size(cgpoint)
+      s.width.should == 1
+      s.height.should == 2
+      CGSizeEqualToSize(s, CGSize.new(cgpoint.x, cgpoint.y)).should == true
+    end
+
+    it 'should accept 1 argument: a CGSize' do
+      cgsize = CGSize.new(1, 2)
+      s = Size(cgsize)
+      s.width.should == 1
+      s.height.should == 2
+      CGSizeEqualToSize(s, cgsize).should == true
+    end
+
+    it 'should accept 1 argument: a UIOffset' do
+      uioffset = UIOffset.new(1, 2)
+      s = Size(uioffset)
+      s.width.should == 1
+      s.height.should == 2
+      CGSizeEqualToSize(s, CGSize.new(uioffset.horizontal, uioffset.vertical)).should == true
+    end
+
+    it 'should accept 1 argument: an Array' do
+      array = [1, 2]
+      s = Size(array)
+      s.width.should == 1
+      s.height.should == 2
+      CGSizeEqualToSize(s, CGSize.new(array[0], array[1])).should == true
+    end
+
+    it 'should accept 2 arguments: two numbers' do
+      args = [1, 2]
+      s = Size(*args)
+      s.width.should == 1
+      s.height.should == 2
+      CGSizeEqualToSize(s, CGSize.new(args[0], args[1])).should == true
+    end
+  end
+
+  describe 'Rect()' do
+    it 'should accept 1 argument: a CGRect' do
+      cgr = CGRect.new([1, 2], [3, 4])
+      r = Rect(cgr)
+      r.origin.x.should == 1
+      r.origin.y.should == 2
+      r.size.width.should == 3
+      r.size.height.should == 4
+      CGRectEqualToRect(r, cgr).should == true
+    end
+
+    it 'should accept 1 argument: a UIView' do
+      uiview = UIView.alloc.initWithFrame([[1, 2], [3, 4]])
+      r = Rect(uiview)
+      r.origin.x.should == 1
+      r.origin.y.should == 2
+      r.size.width.should == 3
+      r.size.height.should == 4
+      CGRectEqualToRect(r, uiview.frame).should == true
+    end
+
+    it 'should accept 1 argument: a CALayer' do
+      calayer = CALayer.alloc.init
+      calayer.frame = [[1, 2], [3, 4]]
+      r = Rect(calayer)
+      r.origin.x.should == 1
+      r.origin.y.should == 2
+      r.size.width.should == 3
+      r.size.height.should == 4
+      CGRectEqualToRect(r, calayer.frame).should == true
+    end
+
+    it 'should accept 1 argument: an Array of 2 arrays' do
+      array = [[1, 2], [3, 4]]
+      r = Rect(array)
+      r.origin.x.should == 1
+      r.origin.y.should == 2
+      r.size.width.should == 3
+      r.size.height.should == 4
+      CGRectEqualToRect(r, CGRect.new(array[0], array[1])).should == true
+    end
+
+    it 'should accept 1 argument: an Array of 4 numbers' do
+      array = [1, 2, 3, 4]
+      r = Rect(array)
+      r.origin.x.should == 1
+      r.origin.y.should == 2
+      r.size.width.should == 3
+      r.size.height.should == 4
+      CGRectEqualToRect(r, CGRect.new([array[0], array[1]], [array[2], array[3]])).should == true
+    end
+
+    it 'should accept 2 arguments (CGPoint, CGSize)' do
+      args = [CGPoint.new(1, 2), CGSize.new(3, 4)]
+      r = Rect(*args)
+      r.origin.x.should == 1
+      r.origin.y.should == 2
+      r.size.width.should == 3
+      r.size.height.should == 4
+      CGRectEqualToRect(r, CGRect.new(args[0], args[1])).should == true
+    end
+
+    it 'should accept 2 arguments: (CGPoint, CGSize)' do
+      args = [CGPoint.new(1, 2), CGSize.new(3, 4)]
+      r = Rect(*args)
+      r.origin.x.should == 1
+      r.origin.y.should == 2
+      r.size.width.should == 3
+      r.size.height.should == 4
+      CGRectEqualToRect(r, CGRect.new(args[0], args[1])).should == true
+    end
+
+    it 'should accept 3 arguments: ([x, y], w, h)' do
+      args = [[1, 2], 3, 4]
+      r = Rect(*args)
+      r.origin.x.should == 1
+      r.origin.y.should == 2
+      r.size.width.should == 3
+      r.size.height.should == 4
+      CGRectEqualToRect(r, CGRect.new(args[0], [args[1], args[2]])).should == true
+    end
+
+    it 'should accept 3 arguments: (CGPoint, w, h)' do
+      args = [CGPoint.new(1, 2), 3, 4]
+      r = Rect(*args)
+      r.origin.x.should == 1
+      r.origin.y.should == 2
+      r.size.width.should == 3
+      r.size.height.should == 4
+      CGRectEqualToRect(r, CGRect.new(args[0], [args[1], args[2]])).should == true
+    end
+
+    it 'should accept 3 arguments: (x, y, [w, h])' do
+      args = [1, 2, [3, 4]]
+      r = Rect(*args)
+      r.origin.x.should == 1
+      r.origin.y.should == 2
+      r.size.width.should == 3
+      r.size.height.should == 4
+      CGRectEqualToRect(r, CGRect.new([args[0], args[1]], args[2])).should == true
+    end
+
+    it 'should accept 3 arguments: (x, y, CGSize)' do
+      args = [1, 2, CGSize.new(3, 4)]
+      r = Rect(*args)
+      r.origin.x.should == 1
+      r.origin.y.should == 2
+      r.size.width.should == 3
+      r.size.height.should == 4
+      CGRectEqualToRect(r, CGRect.new([args[0], args[1]], args[2])).should == true
+    end
+
+    it 'should accept 4 arguments: 4 numbers' do
+      args = [1, 2, 3, 4]
+      r = Rect(*args)
+      r.origin.x.should == 1
+      r.origin.y.should == 2
+      r.size.width.should == 3
+      r.size.height.should == 4
+      CGRectEqualToRect(r, CGRect.new([args[0], args[1]], [args[2], args[3]])).should == true
+    end
+  end
+
+  describe 'Offset()' do
+    it 'should accept 1 argument: a CGPoint' do
+      cgpoint = CGPoint.new(1, 2)
+      o = Offset(cgpoint)
+      o.horizontal.should == 1
+      o.vertical.should == 2
+      UIOffsetEqualToOffset(o, UIOffset.new(cgpoint.x, cgpoint.y)).should == true
+    end
+
+    it 'should accept 1 argument: a CGSize' do
+      cgsize = CGSize.new(1, 2)
+      o = Offset(cgsize)
+      o.horizontal.should == 1
+      o.vertical.should == 2
+      UIOffsetEqualToOffset(o, UIOffset.new(cgsize.width, cgsize.height)).should == true
+    end
+
+    it 'should accept 1 argument: a UIOffset' do
+      uioffset = UIOffset.new(1, 2)
+      o = Offset(uioffset)
+      o.horizontal.should == 1
+      o.vertical.should == 2
+      UIOffsetEqualToOffset(o, uioffset).should == true
+    end
+
+    it 'should accept 1 argument: a Numeric' do
+      numeric = 5
+      o = Offset(numeric)
+      o.horizontal.should == 5
+      o.vertical.should == 5
+      UIOffsetEqualToOffset(o, UIOffset.new(numeric, numeric)).should == true
+    end
+  end
+
+  describe 'EdgeInsets()' do
+    it 'should accept 1 argument: a CGRect' do
+      cgrect = CGRect.new([1, 2], [3, 4])
+      e = EdgeInsets(cgrect)
+      e.left.should == 1
+      e.top.should == 2
+      e.right.should == 3
+      e.bottom.should == 4
+      UIEdgeInsetsEqualToEdgeInsets(e, UIEdgeInsets.new(cgrect.origin.y, cgrect.origin.x, cgrect.size.height, cgrect.size.width)).should == true
+    end
+
+    it 'should accept 1 argument: a UIEdgeInset' do
+      uiedgeinsets = UIEdgeInsets.new(1, 2, 3, 4)
+      e = EdgeInsets(uiedgeinsets)
+      e.top.should == 1
+      e.left.should == 2
+      e.bottom.should == 3
+      e.right.should == 4
+      UIEdgeInsetsEqualToEdgeInsets(e, uiedgeinsets).should == true
+    end
+
+    it 'should accept 1 argument: a Numeric' do
+      numeric = 5
+      e = EdgeInsets(numeric)
+      e.top.should == 5
+      e.left.should == 5
+      e.bottom.should == 5
+      e.right.should == 5
+      UIEdgeInsetsEqualToEdgeInsets(e, UIEdgeInsets.new(numeric, numeric, numeric, numeric)).should == true
+    end
+
+    it 'should accept 2 arguments: Numerics' do
+      args = [5, 6]
+      e = EdgeInsets(*args)
+      e.top.should == 5
+      e.left.should == 6
+      e.bottom.should == 5
+      e.right.should == 6
+      UIEdgeInsetsEqualToEdgeInsets(e, UIEdgeInsets.new(args[0], args[1], args[0], args[1])).should == true
+    end
+
+    it 'should accept 3 arguments: Numerics' do
+      args = [5, 6, 7]
+      e = EdgeInsets(*args)
+      e.top.should == 5
+      e.left.should == 6
+      e.bottom.should == 7
+      e.right.should == 6
+      UIEdgeInsetsEqualToEdgeInsets(e, UIEdgeInsets.new(args[0], args[1], args[2], args[1])).should == true
+    end
+
+    it 'should accept 4 arguments: Numerics' do
+      args = [5, 6, 7, 8]
+      e = EdgeInsets(*args)
+      e.top.should == 5
+      e.left.should == 6
+      e.bottom.should == 7
+      e.right.should == 8
+      UIEdgeInsetsEqualToEdgeInsets(e, UIEdgeInsets.new(args[0], args[1], args[2], args[3])).should == true
+    end
+  end
+end