sugarcube 0.5 → 0.6

data/README.md

@@ -173,8 +173,41 @@ self.view.show  # => self.hidden = false
 self.view.hide  # => self.hidden = true
 ```
 
- View factories
----------
+###### Animations
+
+jQuery-like animation methods.
+
+```ruby
+# default timeout is 0.3
+view.fade_out { |view|
+  view.removeFromSuperview
+}
+# options:
+view.fade_out(0.5, delay: 0,
+                  options: UIViewAnimationOptionCurveLinear,
+                  opacity: 0.5) { |view|
+  view.removeFromSuperview
+}
+
+view.move_to([0, 100])  # move to position 0, 100
+view.delta_to([0, 100])  # move over 0, down 100, from current position
+
+view.slide :left   # slides the entire view one "page" to the left, right, up, or down
+
+view.shake  # shakes the view.
+# options w/ default values:
+shake offset: 8,   # move 8 px left, and 8 px right
+      repeat: 3,   # three times
+    duration: 0.3, # for a total of 0.3 seconds
+     keypath: 'transform.translate.x'
+
+# vigorous nodding - modifying transform.translation.y:
+view.shake offset: 20, repeat: 10, duration: 5, keypath: 'transform.translation.y'
+# an adorable wiggle - modifying transform.rotation:
+superview.shake offset: 0.1, repeat: 2, duration: 0.5, keypath: 'transform.rotation'
+```
+
+###### View factories
 
 ```ruby
 UIButton.buttonWithType(:custom.uibuttontype)
@@ -303,61 +336,109 @@ test[:my] = 'new'
 
 ###### Is it `CGMakeRect` or `CGRectMake`?
 
-Instead, just use `Rect`, `Size` and `Point`.  These are namespaced in
-`SugarCube::CoreGraphics` module, but I recommend you `include
-SugarCube::CoreGraphics` in app_delegate.rb.
+Instead, just use `Rect`, `Size` and `Point`.  They will happily convert most
+sensible arguments into a `Rect/Size/Point`, which can be treated as a `CGRect`
+object OR as an `Array` (woah).
+
+These are namespaced in `SugarCube::CoreGraphics` module, but I recommend you
+`include SugarCube::CoreGraphics` in app_delegate.rb.
 
 ```ruby
-f = Rect(view.frame)  # converts a CGRect into a CGRectArray
-o = Point(view.frame.origin)  # converts a CGPoint into a CGPointArray
-s = Size(view.frame.size)  # converts a CGSize into a CGSizeArray
+f = Rect(view.frame)  # converts a CGRect into a Rect
+o = Point(view.frame.origin)  # converts a CGPoint into a Point
+s = Size(view.frame.size)  # converts a CGSize into a Size
 
 # lots of other conversions are possible.
+# a UIView or CALayer => view.frame
+f = Rect(view)
 # 4 numbers
 f = Rect(x, y, w, h)
 # or two arrays
 p = Point(x, y)  # or just [x, y] works, too
 s = Size(w, h)  # again, [w, h] is fine
 f = Rect(p, s)
-f = Rect([[x, y], [w, h]])  # same as above (the CG*Array objects will get created for you)
-
-view.frame = f  # Rect returns a CGRectArray, which view.frame can accept
+# like I said, a straight-up array of nested arrays is fine, too.
+f = Rect([[x, y], [w, h]])
 ```
 
-###### Animations
+###### {CGRect,CGPoint,CGSize} is a *real boy*!
 
-jQuery-like animation methods.
+These methods get defined in a module (`SugarCube::CG{Rect,Size,Point}Extensions`),
+and included in `CGRect` *and* `Rect`.  The idea is that you do not have to
+distinguish between the two objects.
+
+These methods all use the methods as described in [CGGeometry Reference][], e.g.
+`CGRectContainsPoint`, `CGRectIntersectsRect`, etc.
 
 ```ruby
-# default timeout is 0.3
-view.fade_out { |view|
-  view.removeFromSuperview
-}
-# options:
-view.fade_out(0.5, delay: 0,
-                  options: UIViewAnimationOptionCurveLinear,
-                  opacity: 0.5) { |view|
-  view.removeFromSuperview
-}
+# intersection / contains
+Point(0, 0).intersects?(Rect(-1, -1, 2, 2))  # => true
+# if a Point intersects a Rect, the Rect intersects the Point, right?
+Rect(-1, -1, 2, 2).intersects? Point(0, 0)  # => true
+
+# CGRect and the gang are real Ruby objects.  Let's treat 'em that way!
+view.frame.contains? Point(10, 10)  # in this case, contains? and intersects? are synonyms
+view.frame.intersects? Rect(0, 0, 10, 10)  #  <= but this one
+view.frame.contains? Rect(0, 0, 10, 10)    #  <= and this one are different.
+
+# CGRect has factory methods for CGRectEmpty, CGRectNull, and - KINDA - CGRectInfinite
+# BUT, there is a bug (?) right now where CGRectIsInfinite(CGRectInfinite) returns false.
+# so instead, I've built my own infinite? method that checks for the special "Infinite" value
+> CGRect.infinite
+=> [[0, 0], [Infinity, Infinity]]
+> CGRect.infinite.infinite?
+=> true
+> CGRect.null
+=> [[Infinity, Infinity], [0.0, 0.0]]
+> CGRect.null.null?
+=> true
+> CGRect.empty
+=> [[0.0, 0.0], [0.0, 0.0]]
+> CGRect.empty.empty?
+=> true
+```
 
-view.move_to([0, 100])  # move to position 0, 100
-view.delta_to([0, 100])  # move over 0, down 100, from current position
+A lot of the methods in CGGeometry Reference are available as instance methods
 
-view.slide :left   # slides the entire view one "page" to the left, right, up, or down
+```ruby
+view.frame.left    # => CGRectGetMinX(view.frame)
+view.frame.right   # => CGRectGetMaxX(view.frame)
+view.frame.top     # => CGRectGetMinY(view.frame)
+view.frame.bottom  # => CGRectGetMaxY(view.frame)
+view.frame.width   # => CGRectGetWidth(view.frame)
+view.frame.height  # => CGRectGetHeight(view.frame)
+view.frame.center  # => Point(CGRectGetMidX(view.frame), CGRectGetMidY(view.frame))
+
+view.frame.intersection(another_rect)  # => CGRectIntersection(view.frame, another_rect)
+view.frame + another_rect  # => CGRectUnion(view.frame, another_rect)
+view.frame + a_point  # => CGRectOffset(view.frame, a_point.x, a_point.y)
+view.frame + a_offset  # => CGRectOffset(view.frame, a_offset.horizontal, a_offset.vertical)
+view.frame + edgeinsets  # => UIEdgeInsetsInsetRect(view.frame, edgeinsets)
+view.frame + a_size  # => CGRectInset(view.frame, -a_size.width, -a_size.height)
+# Adding a size to a view keeps the view's CENTER in the same place, but
+# increases its size by `size.width,size.height`. it's the same as using
+# UIEdgeInsets with top == bottom, and left == right
+> Rect(0, 0, 10, 10).center
+=> Point(5.0, 5.0)  # note the center
+> Rect(0, 0, 10, 10) + Size(10, 10)
+=> Rect([-10.0, -10.0],{30.0 × 30.0})  # origin and size changed, but...
+> (Rect(0, 0, 10, 10) + Size(10, 10)).center
+=> Point(5.0, 5.0)
+# See?  It's bigger, but the center hasn't moved.
+```
 
-view.shake  # shakes the view.
-# options w/ default values:
-shake offset: 8,   # move 8 px left, and 8 px right
-      repeat: 3,   # three times
-    duration: 0.3, # for a total of 0.3 seconds
-     keypath: 'transform.translate.x'
+`to_hash/from_hash`, and notice here that I used `puts`, to show that the `to_s`
+method is a little more readable.
 
-# vigorous nodding - modifying transform.translation.y:
-view.shake offset: 20, repeat: 10, duration: 5, keypath: 'transform.translation.y'
-# an adorable wiggle - modifying transform.rotation:
-superview.shake offset: 0.1, repeat: 2, duration: 0.5, keypath: 'transform.rotation'
+```ruby
+> Rect(0, 0, 10, 10).to_hash
+=> {"Width"=>10.0, "Height"=>10.0, "Y"=>0.0, "X"=>0.0}
+> puts CGRect.from_hash Rect(0, 0, 1, 1).to_hash
+CGRect([0.0, 0.0],{1.0 × 1.0})
 ```
 
+[CGGeometry Reference]: https://developer.apple.com/library/mac/documentation/graphicsimaging/reference/CGGeometry/Reference/reference.html
+
  REPL View adjustments
 -----------------------
 
@@ -413,6 +494,21 @@ Assume I ran `include SugarCube::Adjust` in these examples.
 # if you forget what view you are adjusting, run `adjust` again
 > a
 => {UITextField @ x: 46.0 y:214.0, 280.0×33.0} child of UIView
+```
+
+ Pointers
+----------
+
+These are not UIKit-related, so I reverted to Ruby's preferred `to_foo`
+convention.
+
+```ruby
+[0.0, 1.1, 2.2].to_pointer(:float)
+
+floats = Pointer.new(:float, 3)
+floats[0] = 0.0
+floats[1] = 1.1
+floats[2] = 2.2
 ```
 
 [BubbleWrap]: https://github.com/rubymotion/BubbleWrap

data/lib/sugarcube/adjust.rb

@@ -198,10 +198,10 @@ module SugarCube
 
       if tab
         print tab
-        print is_last ? "`--" : "+--"
+        print is_last ? "`-- " : "+-- "
         tab += is_last ? "    " : "|   "
       else
-        print "."
+        print ". "
         tab = ""
       end
       puts view.inspect

data/lib/sugarcube/array.rb

@@ -0,0 +1,11 @@
+class Array
+
+  def to_pointer(type)
+    ret = Pointer.new(type, self.length)
+    self.each_index do |i|
+      ret[i] = self[i]
+    end
+    ret
+  end
+
+end

data/lib/sugarcube/core_graphics.rb

@@ -1,190 +1,401 @@
+module SugarCube
+  # Extensions to make CGRect a "real class"
+  module CGRectExtensions
+    module ClassMethods
 
-class CGRectArray < Array
+      def empty
+        SugarCube::CoreGraphics::Rect(CGRectZero)
+      end
 
-  def initialize args
-    if args.length == 4
-      super [CGPointArray.new([args[0], args[1]]), CGSizeArray.new([args[2], args[3]])]
-    else
-      unless CGPointArray === args[0]
-        args[0] = SugarCube::CoreGraphics::Point(args[0])
+      def null
+        SugarCube::CoreGraphics::Rect(CGRectNull)
       end
-      unless CGSizeArray === args[1]
-        args[1] = SugarCube::CoreGraphics::Size(args[1])
+
+      def infinite
+        SugarCube::CoreGraphics::Rect([0, 0], CGSize.infinite)
+      end
+
+      def from_hash(hash)
+        ret = Pointer.new(CGRect.type)
+        if CGRectMakeWithDictionaryRepresentation(hash, ret)
+          ret[0]
+        else
+          nil
+        end
       end
-      super [args[0], args[1]]
     end
-  end
 
-  def origin
-    return self[0]
-  end
+    def self.included(base)
+      base.extend(ClassMethods)
+    end
 
-  def origin= val
-    self[0] = SugarCube::CoreGraphics::Point(val)
-  end
+    def empty?
+      CGRectIsEmpty(self)
+    end
 
-  def size
-    return self[1]
-  end
+    def infinite?
+      self.size.infinite?
+    end
 
-  def size= val
-    self[1] = SugarCube::CoreGraphics::Size(val)
-  end
+    def null?
+      CGRectIsNull(self)
+    end
 
-  # returns an intersection of self and rect, or moves the Rect using Point,
-  # or increases the size using Size
-  def +(rect)
-    case rect
-    when CGRectArray
-      x1 = self.origin.x < rect.origin.x ? self.origin.x : rect.origin.x
-      y1 = self.origin.y < rect.origin.y ? self.origin.y : rect.origin.y
-      x2 = self.origin.x + self.size.width > rect.origin.x + rect.size.width ? self.origin.x + self.size.width : rect.origin.x + rect.size.width
-      y2 = self.origin.y + self.size.height > rect.origin.y + rect.size.height ? self.origin.y + self.size.height : rect.origin.y + rect.size.height
-      SugarCube::CoreGraphics::Rect(x1, y1, x2-x1, y2-y1)
-    when CGPointArray
-      x = self.origin.x + rect.x
-      y = self.origin.y + rect.y
-      SugarCube::CoreGraphics::Rect([[x, y], self.size])
-    when CGSizeArray
-      w = self.size.width + rect.width
-      h = self.size.height + rect.height
-      SugarCube::CoreGraphics::Rect([self.origin, [w, h]])
-    else
-      super
+    def left
+      return CGRectGetMinX(self)
     end
-  end
 
-end
+    def right
+      return CGRectGetMaxX(self)
+    end
 
+    def width
+      return CGRectGetWidth(self)
+    end
 
-class CGPointArray < Array
+    def top
+      return CGRectGetMinY(self)
+    end
 
-  def x
-    return self[0]
-  end
+    def bottom
+      return CGRectGetMaxY(self)
+    end
 
-  def x= val
-    self[0] = val
-  end
+    def height
+      return CGRectGetHeight(self)
+    end
 
-  def y
-    return self[1]
-  end
+    def center
+      return SugarCube::CoreGraphics::Point(CGRectGetMidX(self), CGRectGetMidY(self))
+    end
 
-  def y= val
-    self[1] = val
-  end
+    def to_s
+      "#{self.class.name}([#{self.origin.x}, #{self.origin.y}],{#{self.size.width} × #{self.size.height}})"
+    end
 
-  # adds a vector to this point, or creates a Rect by adding a size
-  def +(point)
-    case point
-    when CGPointArray
-      x = self.x + point.x
-      y = self.y + point.y
-      CGPointArray[x, y]
-    when CGSizeArray
-      CGRectArray[self, point]
-    else
-      super
+    def to_hash
+      CGRectCreateDictionaryRepresentation(self)
     end
-  end
 
-end
+    def inspect ; to_s ; end
+
+    # # returns an intersection of self and rect, or moves the Rect using Point,
+    # or increases the size using Size
+    def +(rect)
+      case rect
+      when SugarCube::CoreGraphics::Rect, CGRect
+        SugarCube::CoreGraphics::Rect(CGRectUnion(self, rect))
+      when SugarCube::CoreGraphics::Point, CGPoint
+        SugarCube::CoreGraphics::Rect(CGRectOffset(self, rect.x, rect.y))
+      when SugarCube::CoreGraphics::Offset, UIOffset
+        SugarCube::CoreGraphics::Rect(CGRectOffset(self, rect.horizontal, rect.vertical))
+      when SugarCube::CoreGraphics::Size, CGSize
+        SugarCube::CoreGraphics::Rect(CGRectInset(self, - rect.width, - rect.height))
+      when SugarCube::CoreGraphics::EdgeInsets, UIEdgeInsets
+        SugarCube::CoreGraphics::Rect(UIEdgeInsetsInsetRect(self, rect))
+      else
+        super
+      end
+    end
 
-class CGSizeArray < Array
+    def intersection(rect)
+      SugarCube::CoreGraphics::Rect(CGRectIntersection(self, rect))
+    end
 
-  def width
-    return self[0]
-  end
+    def intersects?(rect_or_point)
+      case rect_or_point
+      when SugarCube::CoreGraphics::Point, CGPoint
+        CGRectContainsPoint(self, rect_or_point)
+      when Array, CGRect
+        CGRectIntersectsRect(self, rect_or_point)
+      else
+        super
+      end
+    end
 
-  def width= val
-    self[0] = val
-  end
+    def contains?(rect_or_point)
+      case rect_or_point
+      when SugarCube::CoreGraphics::Point, CGPoint
+        CGRectContainsPoint(self, rect_or_point)
+      when Array, CGRect
+        CGRectContainsRect(self, rect_or_point)
+      else
+        super
+      end
+    end
 
-  def height
-    return self[1]
-  end
+    def ==(rect)
+      CGRectEqualToRect(self, rect)
+    end
 
-  def height= val
-    self[1] = val
   end
 
-  # adds the sizes
-  def +(size)
-    case size
-    when CGSizeArray
-      width = self.width + size.width
-      height = self.height + size.height
-      CGSizeArray[width, height]
-    when CGPointArray
-      CGRectArray[size, self]
-    else
-      super
+  # Extensions to make CGPoint a "real class"
+  module CGPointExtensions
+    module ClassMethods
+      def from_hash(hash)
+        ret = Pointer.new(CGPoint.type)
+        if CGPointMakeWithDictionaryRepresentation(hash, ret)
+          ret[0]
+        else
+          nil
+        end
+      end
     end
-  end
 
-end
+    def self.included(base)
+      base.extend(ClassMethods)
+    end
 
+    def intersects?(rect)
+      CGRectContainsPoint(rect, self)
+    end
 
-class UIEdgeInsetsArray < Array
+    def ==(point)
+      CGPointEqualToPoint(self, point)
+    end
 
-  def top
-    return self[0]
-  end
+    def to_s
+      "#{self.class.name}(#{self.x}, #{self.y})"
+    end
 
-  def top= val
-    self[0] = val
-  end
+    def to_hash
+      CGPointCreateDictionaryRepresentation(self)
+    end
 
-  def left
-    return self[1]
-  end
+    def inspect ; to_s ; end
 
-  def left= val
-    self[1] = val
   end
 
-  def bottom
-    return self[2]
-  end
+  # Extensions to make CGSize a "real class"
+  module CGSizeExtensions
+    module ClassMethods
+      def infinite
+        infinity = CGRect.null[0][0]
+        SugarCube::CoreGraphics::Size(infinity, infinity)
+      end
 
-  def bottom= val
-    self[2] = val
-  end
+      def from_hash(hash)
+        ret = Pointer.new(CGSize.type)
+        if CGSizeMakeWithDictionaryRepresentation(hash, ret)
+          ret[0]
+        else
+          nil
+        end
+      end
+    end
 
-  def right
-    return self[3]
-  end
+    def self.included(base)
+      base.extend(ClassMethods)
+    end
 
-  def right= val
-    self[3] = val
-  end
+    def infinite?
+      infinity = CGRect.null[0][0]
+      self.width == infinity or self.height == infinity
+    end
 
-end
+    def ==(size)
+      CGSizeEqualToSize(self, size)
+    end
+
+    def to_s
+      "#{self.class.name}(#{self.width} × #{self.height})"
+    end
 
+    def to_hash
+      CGSizeCreateDictionaryRepresentation(self)
+    end
 
-class UIOffsetArray < Array
+    def inspect ; to_s ; end
 
-  def horizontal
-    return self[0]
   end
+end
 
-  def horizontal= val
-    self[0] = val
-  end
 
-  def vertical
-    return self[1]
-  end
+class CGRect
+  include SugarCube::CGRectExtensions
+end
+
+
+class CGPoint
+  include SugarCube::CGPointExtensions
+end
 
-  def vertical= val
-    self[1] = val
-  end
 
+class CGSize
+  include SugarCube::CGSizeExtensions
 end
 
+
 module SugarCube
   module CoreGraphics
+    PI  = 3.141592654
+    PHI = 1.618033989
+    E   = 2.718281828
+
+    class Rect < Array
+      include SugarCube::CGRectExtensions
+
+      def initialize args
+        if args.length == 4
+          super [Point.new([args[0], args[1]]), Size.new([args[2], args[3]])]
+        else
+          unless args[0].is_a? Point
+            args[0] = Point(args[0])
+          end
+          unless args[1].is_a? Size
+            args[1] = Size(args[1])
+          end
+          super [args[0], args[1]]
+        end
+      end
+
+      def origin
+        return self[0]
+      end
+
+      def origin= val
+        self[0] = Point(val)
+      end
+
+      def size
+        return self[1]
+      end
+
+      def size= val
+        self[1] = Size(val)
+      end
+    end
+
+
+    class Point < Array
+      include SugarCube::CGPointExtensions
+
+      def x
+        return self[0]
+      end
+
+      def x= val
+        self[0] = val
+      end
+
+      def y
+        return self[1]
+      end
+
+      def y= val
+        self[1] = val
+      end
+
+      # adds a vector to this point, or creates a Rect by adding a size
+      def +(point)
+        case point
+        when Point, CGPoint
+          x = self.x + point.x
+          y = self.y + point.y
+          Point[x, y]
+        when Size, CGSize
+          Rect[self, point]
+        else
+          super
+        end
+      end
+    end
+
+
+    class Size < Array
+      include SugarCube::CGSizeExtensions
+
+      def width
+        return self[0]
+      end
+
+      def width= val
+        self[0] = val
+      end
+
+      def height
+        return self[1]
+      end
+
+      def height= val
+        self[1] = val
+      end
+
+      # adds the sizes
+      def +(size)
+        case size
+        when Size, CGSize
+          width = self.width + size.width
+          height = self.height + size.height
+          Size[width, height]
+        when Point, CGPoint
+          Rect[size, self]
+        else
+          super
+        end
+      end
+
+    end
+
+
+    class EdgeInsets < Array
+
+      def top
+        return self[0]
+      end
+
+      def top= val
+        self[0] = val
+      end
+
+      def left
+        return self[1]
+      end
+
+      def left= val
+        self[1] = val
+      end
+
+      def bottom
+        return self[2]
+      end
+
+      def bottom= val
+        self[2] = val
+      end
+
+      def right
+        return self[3]
+      end
+
+      def right= val
+        self[3] = val
+      end
+
+    end
+
+
+    class Offset < Array
+
+      def horizontal
+        return self[0]
+      end
+
+      def horizontal= val
+        self[0] = val
+      end
+
+      def vertical
+        return self[1]
+      end
+
+      def vertical= val
+        self[1] = val
+      end
+
+    end
+
     module_function
 
     def Size(w_or_size, h=nil)
@@ -202,7 +413,7 @@ module SugarCube
       else
         w = w_or_size
       end
-      return CGSizeArray.new([w, h])
+      return Size.new([w, h])
     end
 
     def Point(x_or_origin, y=nil)
@@ -220,11 +431,11 @@ module SugarCube
       else
         x = x_or_origin
       end
-      return CGPointArray.new([x, y])
+      return Point.new([x, y])
     end
 
     # Accepts 1, 2 or 4 arguments.
-    # 1 argument should be an Array[4], CGRectArray, or CGRect
+    # 1 argument should be an Array[4], Rect, or CGRect
     # 2 arguments should be a Point/CGPoint and a Size/CGSize,
     # 4 should be x, y, w, h
     def Rect(x_or_origin, y_or_size=nil, w=nil, h=nil)
@@ -235,7 +446,12 @@ module SugarCube
           y = x_or_origin.origin.y
           w = x_or_origin.size.width
           h = x_or_origin.size.height
-        when CGRectArray
+        when UIView, CALayer
+          x = x_or_origin.frame.origin.x
+          y = x_or_origin.frame.origin.y
+          w = x_or_origin.frame.size.width
+          h = x_or_origin.frame.size.height
+        when Rect
           x = x_or_origin[0][0]
           y = x_or_origin[0][1]
           w = x_or_origin[1][0]
@@ -258,17 +474,17 @@ module SugarCube
           raise RuntimeError.new("Invalid argument sent to Rect(#{x_or_origin.inspect})")
         end
       elsif not w and not h
-        x_or_origin = Point(x_or_origin) unless x_or_origin.is_a? CGPointArray
+        x_or_origin = Point(x_or_origin) unless x_or_origin.is_a? Point
         x = x_or_origin.x
         y = x_or_origin.y
-        y_or_size = Size(y_or_size) unless y_or_size.is_a? CGSizeArray
+        y_or_size = Size(y_or_size) unless y_or_size.is_a? Size
         w = y_or_size.width
         h = y_or_size.height
       else
         x = x_or_origin
         y = y_or_size
       end
-      return CGRectArray.new([[x, y], [w, h]])
+      return Rect.new([[x, y], [w, h]])
     end
 
     # Accepts 1 or 4 arguments.
@@ -295,7 +511,7 @@ module SugarCube
       else
         top = top_or_inset
       end
-      return UIEdgeInsetsArray.new([top, left, bottom, right])
+      return EdgeInsets.new([top, left, bottom, right])
     end
 
     # Accepts 1 or 2 arguments.
@@ -319,7 +535,7 @@ module SugarCube
       else
         horizontal = horizontal_or_offset
       end
-      return UIOffsetArray.new([horizontal, vertical])
+      return Offset.new([horizontal, vertical])
     end
 
   end

data/lib/sugarcube/fixnum.rb

@@ -3,8 +3,8 @@ class Fixnum
   #     0xffffff.uicolor
   #     0xffffff.uicolor(0.33)
   # =>
-  #     UIColor.colorWithRed(1.0, green:1.0, red: 1.0, alpha:1.0)
-  #     UIColor.colorWithRed(1.0, green:1.0, red: 1.0, alpha:0.33)
+  #     UIColor.colorWithRed(1.0, green:1.0, blue: 1.0, alpha:1.0)
+  #     UIColor.colorWithRed(1.0, green:1.0, blue: 1.0, alpha:0.33)
   def uicolor(alpha=nil)
     alpha = 1.0 if alpha.nil?
 

data/lib/sugarcube/to_s/nsset.rb

@@ -0,0 +1,7 @@
+class NSSet
+
+  def to_s
+    "NSSet(#{self.count}){#{self.allObjects.map{|o| o.inspect}.join(', ')}}"
+  end
+
+end

data/lib/sugarcube/to_s/uievent.rb

@@ -0,0 +1,40 @@
+class UIEvent
+
+  def to_s
+    type = case self.type
+            when UIEventTypeTouches
+              "touch"
+            when UIEventTypeMotion
+              if self.subtype == UIEventSubtypeMotionShake
+                "shake"
+              else
+                "motion"
+              end
+            when UIEventTypeRemoteControl
+              case self.subtype
+              when UIEventSubtypeRemoteControlPlay
+                "remote-control, Play"
+              when UIEventSubtypeRemoteControlPause
+                "remote-control, Pause"
+              when UIEventSubtypeRemoteControlStop
+                "remote-control, Stop"
+              when UIEventSubtypeRemoteControlTogglePlayPause
+                "remote-control, TogglePlayPause"
+              when UIEventSubtypeRemoteControlNextTrack
+                "remote-control, NextTrack"
+              when UIEventSubtypeRemoteControlPreviousTrack
+                "remote-control, PreviousTrack"
+              when UIEventSubtypeRemoteControlBeginSeekingBackward
+                "remote-control, BeginSeekingBackward"
+              when UIEventSubtypeRemoteControlEndSeekingBackward
+                "remote-control, EndSeekingBackward"
+              when UIEventSubtypeRemoteControlBeginSeekingForward
+                "remote-control, BeginSeekingForward"
+              when UIEventSubtypeRemoteControlEndSeekingForward
+                "remote-control, EndSeekingForward"
+              end
+            end
+    "#{self.class.name}(#{type}, touches: #{allTouches.inspect})"
+  end
+
+end

data/lib/sugarcube/to_s/uitouch.rb

@@ -0,0 +1,20 @@
+class UITouch
+
+  def to_s
+    phase = case self.phase
+            when UITouchPhaseBegan
+              "began"
+            when UITouchPhaseMoved
+              "moved"
+            when UITouchPhaseStationary
+              "stationary"
+            when UITouchPhaseEnded
+              "ended"
+            when UITouchPhaseCancelled
+              "cancelled"
+            end
+    "#{self.class.name}(#{self.tapCount} #{self.tapCount == 1 ? 'tap' : 'taps'} #{phase},"\
+                      " at #{self.locationInView(self.view).inspect}, @ #{self.timestamp})"
+  end
+
+end

data/lib/sugarcube/to_s/uiview.rb

@@ -0,0 +1,8 @@
+class UIView
+
+  def to_s
+    "#{self.class.name}(##{self.object_id}, #{self.frame.inspect}, "\
+                        "#{self.superview ? ' child of ' + self.superview.class.name + ' #' + self.superview.object_id.to_s : ''})"
+  end
+
+end

data/lib/sugarcube/uialertview.rb

@@ -2,7 +2,7 @@ class UIAlertView
 
   # UIAlertView.alert("title",
   #   message: "help!",
-  #   buttons: %w"OK Cancel Go Away",
+  #   buttons: %w"OK Cancel No-way",
   #   cancel: proc{ puts "nevermind" },
   #   success: proc{ |pressed| puts "pressed: #{pressed}" },
   #   )

data/lib/sugarcube/uiview.rb

@@ -4,12 +4,6 @@ class UIView
     self.addSubview view
   end
 
-  def to_s
-    "{#{self.class.name} @ x: #{self.frame.origin.x} y:#{self.frame.origin.y}, "\
-                        "#{self.frame.size.width}×#{self.frame.size.height}}"\
-                        "#{self.superview ? ' child of ' + self.superview.class.name : ''}"
-  end
-
   def show
     self.hidden = false
     self

data/lib/sugarcube/version.rb

@@ -1,3 +1,3 @@
 module SugarCube
-  Version = '0.5'
+  Version = '0.6'
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: sugarcube
 version: !ruby/object:Gem::Version
-  version: '0.5'
+  version: '0.6'
   prerelease: 
 platform: ruby
 authors:
@@ -10,11 +10,11 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-07-26 00:00:00.000000000 Z
+date: 2012-07-30 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
-  requirement: &70125432971500 !ruby/object:Gem::Requirement
+  requirement: &70171931302100 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -22,10 +22,10 @@ dependencies:
         version: '0'
   type: :runtime
   prerelease: false
-  version_requirements: *70125432971500
+  version_requirements: *70171931302100
 - !ruby/object:Gem::Dependency
   name: rspec
-  requirement: &70125432986920 !ruby/object:Gem::Requirement
+  requirement: &70171931301160 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -33,7 +33,7 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *70125432986920
+  version_requirements: *70171931301160
 description: ! 'CocoaTouch/iOS is a *verbose* framework.  These extensions hope to
   make
 
@@ -65,6 +65,7 @@ files:
 - Rakefile
 - lib/sugarcube.rb
 - lib/sugarcube/adjust.rb
+- lib/sugarcube/array.rb
 - lib/sugarcube/core_graphics.rb
 - lib/sugarcube/defaults.rb
 - lib/sugarcube/document.rb
@@ -76,6 +77,10 @@ files:
 - lib/sugarcube/numeric.rb
 - lib/sugarcube/symbol.rb
 - lib/sugarcube/symbol/symbol_uicolor.rb
+- lib/sugarcube/to_s/nsset.rb
+- lib/sugarcube/to_s/uievent.rb
+- lib/sugarcube/to_s/uitouch.rb
+- lib/sugarcube/to_s/uiview.rb
 - lib/sugarcube/uialertview.rb
 - lib/sugarcube/uibutton.rb
 - lib/sugarcube/uicolor.rb