sugarcube 0.14.0 → 0.15.0

data/README.md

@@ -467,8 +467,20 @@ image.rotate(:right)
 image.rotate(:flip)  # 180° - if you have a better name, let me know!
 image.rotate(45.degrees)
 
-image.scale_to(new_size)  # won't stretch
-image.in_rect(frame)  # stretches
+image.in_rect(frame)  # returns the part of the image contained in frame
+image.scale_to(new_size)  # won't stretch, but the image might have transparent padding
+image.scale_to(new_size, background: :white)  # adds a white background before padding
+image.scale_within(new_size)  # same as scale_to in that it doesn't stretch the
+# image, but the size is not guaranteed to be new_size.  It is guaranteed not to
+# be *bigger* than new_size
+image.scale_to_fill(new_size)  # again, like scale_to, but the image is guaranteed
+# to completely fill new_size, even if some of the image has to be cropped to fit.
+# You can control which side or corner you prefer to remain visible.  because the
+# aspect ratio is maintained, only ONE dimension will need to be cropped.
+image.scale_to_fill(new_size, position: :top_left)
+
+# returns a UIColor (and supports retina images)
+image.color_at([5, 5])
 
 # default insets are UIEdgeInsetsZero
 image.tileable
@@ -481,6 +493,21 @@ image.stretchable(insets)
 image.masked(mask_image)
 ```
 
+#### 568
+
+If you `require 'sugarcube-568'` in your Rakefile, you can use
+`UIImage.imageNamed()` to load images that are specific to the 4" iphone.
+
+```ruby
+'tall'.uiimage
+# => tall.png on iphone 3g
+# => tall@2x.png on iphone 4
+# => tall-568h@2x.png on iphone 5
+```
+
+This code is ported from <https://github.com/gaj/imageNamed568>, which I had
+some problems with on RubyMotion (it worked, but not *always*.  Very strange).
+
 UIAlertView
 --------
 
@@ -575,9 +602,12 @@ view.fade_out(0.5, delay: 0,
   view.removeFromSuperview
 }
 
-view.move_to([0, 100])  # move to position 0, 100
+view.move_to([0, 100])   # move to position 0, 100
 view.delta_to([0, 100])  # move over 0, down 100, from current position
 
+view.rotate_to Math::PI  # rotate view upside down
+view.rotate_to(duration: 0.5, angle: 45.degrees)  # using options
+
 view.slide :left   # slides the entire view one "page" to the left, right, up, or down
 
 view.shake  # shakes the view.

data/Rakefile

@@ -1,8 +1,13 @@
 $:.unshift('/Library/RubyMotion/lib')
 require 'motion/project'
 require './lib/sugarcube'
+require './lib/sugarcube-gestures'
+require './lib/sugarcube-568'
+
 
 Motion::Project::App.setup do |app|
   # Use `rake config' to see complete project settings.
   app.name = 'SugarCube'
+
+  app.frameworks << 'CoreLocation'
 end

data/lib/sugarcube/nsarray.rb

@@ -1,6 +1,6 @@
 class NSArray
 
-  # @param [Symbol] type A pointer type from the list at {http://www.rubymotion.com/developer-center/guides/runtime/ RubyMotion Pointers Reference#_pointers}
+  # @param type [Symbol] type A pointer type from the list at {http://www.rubymotion.com/developer-center/guides/runtime/ RubyMotion Pointers Reference#_pointers}
   # @return [Pointer] A pointer to the array, of the specified type
   def to_pointer(type)
     ret = Pointer.new(type, self.length)

data/lib/sugarcube/nsdate.rb

@@ -1,7 +1,12 @@
 class NSDate
 
-  def self.new
-    self.date
+  def self.from_components(components)
+    components = NSDateComponents.new
+    components.each do |property,value|
+      components.send("#{property}=", value)
+    end
+    calendar = NSCalendar.alloc.initWithCalendarIdentifier(NSGregorianCalendar)
+    return calendar.dateFromComponents(components)
   end
 
   def string_with_style(style)

data/lib/sugarcube/uiimage.rb

@@ -27,22 +27,193 @@ class UIImage
   ##|  <http://www.catamount.com/blog/uiimage-extensions-for-cutting-scaling-and-rotating-uiimages/>
   ##|  <http://www.catamount.com/forums/viewtopic.php?f=21&t=967>
   ##|
+
+  # Merges the two images.  The target is drawn first, `image` is drawn on top.
+  def <<(image)
+    size = self.size
+    if image.size.width > size.width
+      size.width = image.size.width
+    end
+    if image.size.height > size.height
+      size.height = image.size.height
+    end
+
+    UIGraphicsBeginImageContextWithOptions(size, false, self.scale)
+    self.drawAtPoint([0, 0])
+    # draw the border and drop shadow
+    image.drawAtPoint([0, 0])
+    new_image = UIGraphicsGetImageFromCurrentImageContext()
+    UIGraphicsEndImageContext()
+    return new_image
+  end
+
+  ##|
+  ##|  image scaling
+  ##|
+
+  # This method is used to crop an image.  Scale (retina or non-retina) is preserved.
+  #
+  # @param rect [CGRect] the portion of the image to return
+  # @return [UIImage]
   def in_rect(rect)
-    # not necessary, since we don't modify/examine the rect
-    # rect = SugarCube::CoreGraphics::Rect(rect)
     imageRef = CGImageCreateWithImageInRect(self.CGImage, rect)
-    sub_image = UIImage.imageWithCGImage(imageRef)
+    sub_image = UIImage.imageWithCGImage(imageRef, scale:self.scale, orientation:self.imageOrientation)
 
     return sub_image
   end
 
+  # Delegates to scale_to_fill(position: :center)
+  def scale_to_fill(new_size)
+    scale_to_fill(new_size, position: :center)
+  end
+
+  # Scales an image to fit within the given size, stretching one or both
+  # dimensions so that it completely fills the area.   The current aspect ratio
+  # is maintained.  If you want to place an image inside a container image, this
+  # is the method to use.
+  #
+  # You can specify a `position` property, which can be a symbol or a point.  It
+  # specifies where you want the image located if it has to be cropped.
+  # Specifying the top-left corner will display the top-left corner of the
+  # image, likewise specifing the bottom-right corner will display *that*
+  # corner.  If you want the image centered, you can use the 'position-less'
+  # version of this method (`scale_to_fit()`) or specify the point at the center
+  # of the image (`scale_to_fit(size, position:[w/2, h/2])`), or use a symbol
+  # (`scale_to_fit(size, position: :center)`).
+  #
+  # @param new_size [CGSize] Minimum dimensions of desired image.  The returned image is
+  #   guaranteed to fit within these dimensions.
+  # @param position [Symbol, CGPoint] Where to position the resized image. Valid symbols
+  #   are: `[:topleft, :top, :topright, :left, :center, :right, :bottomleft,
+  #   :bottom, :bottomright]` (if you forget and use an underscore, like
+  #   `top_left`, that'll work, too)
+  # @return [UIImage]
+  def scale_to_fill(new_size, position:position)
+    new_size = SugarCube::CoreGraphics::Size(new_size)
+    my_size = self.size
+
+    if my_size.width < new_size.width
+      my_size.height *= new_size.width / my_size.width
+      my_size.width = new_size.width
+    end
+
+    if my_size.height < new_size.height
+      my_size.width *= new_size.height / my_size.height
+      my_size.height = new_size.height
+    end
+
+    if self.size.width == my_size.width && self.size.height == my_size.height
+      return self
+    end
+
+    if position.is_a?(Symbol)
+      min_x = 0
+      min_y = 0
+      max_x = my_size.width;
+      max_y = my_size.height;
+      mid_x = max_x / 2
+      mid_y = max_y / 2
+      case position
+      when :top_left, :topleft
+        position = SugarCube::CoreGraphics::Point(min_x, min_y)
+      when :top
+        position = SugarCube::CoreGraphics::Point(mid_x, min_y)
+      when :top_right, :topright
+        position = SugarCube::CoreGraphics::Point(max_x, min_y)
+      when :left
+        position = SugarCube::CoreGraphics::Point(min_x, mid_x)
+      when :center
+        position = SugarCube::CoreGraphics::Point(mid_x, mid_x)
+      when :right
+        position = SugarCube::CoreGraphics::Point(max_x, mid_x)
+      when :bottom_left, :bottomleft
+        position = SugarCube::CoreGraphics::Point(min_x, max_y)
+      when :bottom
+        position = SugarCube::CoreGraphics::Point(mid_x, max_y)
+      when :bottom_right, :bottomright
+        position = SugarCube::CoreGraphics::Point(max_x, max_y)
+      else
+        raise "Unknown position #{position.inspect}"
+      end
+    else
+      position = SugarCube::CoreGraphics::Point(position)
+    end
+    thumbnail_x = position.x * (new_size.width - my_size.width) / my_size.width
+    thumbnail_y = position.y * (new_size.height - my_size.height) / my_size.height
+
+    UIGraphicsBeginImageContextWithOptions(new_size, false, self.scale)
+    thumbnail_rect = CGRectZero
+    thumbnail_rect.origin = [thumbnail_x, thumbnail_y]
+    thumbnail_rect.size  = my_size
+
+    self.drawInRect(thumbnail_rect)
+
+    new_image = UIGraphicsGetImageFromCurrentImageContext()
+    UIGraphicsEndImageContext()
+
+    raise "could not scale image"  unless new_image
+
+    return new_image
+  end
+
+  # This method is similar to `scale_to`, except it doesn't pad the image, it
+  # just scales the image so that it will fit inside the new bounds.
+  def scale_within(new_size)
+    target_size = SugarCube::CoreGraphics::Size(new_size)
+    image_size = self.size
+
+    if CGSizeEqualToSize(target_size, self.size)
+      return self
+    end
+
+    width = image_size.width
+    height = image_size.height
+
+    target_width = target_size.width
+    target_height = target_size.height
+
+    width_factor = target_width / width
+    height_factor = target_height / height
+
+    if width_factor < height_factor
+      scale_factor = width_factor
+    else
+      scale_factor = height_factor
+    end
+
+    if scale_factor == 1
+      return self
+    end
+
+    scaled_size = CGSize.new(width * scale_factor, height * scale_factor)
+    return scale_to(scaled_size)
+  end
+
+  # Delegates to scale_to(background:), specifying background color of `nil`
   def scale_to(new_size)
+    scale_to(new_size, background:nil)
+  end
+
+  # Scales an image to fit within the given size.  Its current aspect ratio is
+  # maintained, but the image is padded so that it fills the entire area. If the
+  # image is too small, it will be scaled up to fit. If you specify a
+  # background that color will be used, otherwise the background will be
+  # transparent.
+  #
+  # @param new_size [CGSize] Maximum dimensions of desired image.  The returned image is
+  #   guaranteed to fit within these dimensions.
+  # @param background [UIColor] Color to fill padded areas.  Default is transparent.
+  # @return [UIImage]
+  def scale_to(new_size, background:background)
     new_size = SugarCube::CoreGraphics::Size(new_size)
 
-    sourceImage = self
-    newImage = nil
+    image_size = self.size
+
+    if CGSizeEqualToSize(image_size, new_size)
+      return self
+    end
 
-    image_size = sourceImage.size
+    new_image = nil
     width = image_size.width
     height = image_size.height
 
@@ -54,39 +225,44 @@ class UIImage
     scaled_height = target_height
 
     thumbnail_point = CGPoint.new(0.0, 0.0)
+    width_factor = target_width / width
+    height_factor = target_height / height
 
-    unless CGSizeEqualToSize(image_size, new_size)
-      width_factor = target_width / width
-      heightFactor = target_height / height
-
-      if width_factor < heightFactor
-        scale_factor = width_factor
-      else
-        scale_factor = heightFactor
-      end
+    if width_factor < height_factor
+      scale_factor = width_factor
+    else
+      scale_factor = height_factor
+    end
 
-      scaled_width  = width * scale_factor
-      scaled_height = height * scale_factor
+    scaled_width  = width * scale_factor
+    scaled_height = height * scale_factor
 
-      # center the image
+    # center the image
 
-      if width_factor < heightFactor
-        thumbnail_point.y = (target_height - scaled_height) * 0.5
-      elsif width_factor > heightFactor
-        thumbnail_point.x = (target_width - scaled_width) * 0.5
-      end
+    if width_factor < height_factor
+      thumbnail_point.y = (target_height - scaled_height) * 0.5
+    elsif width_factor > height_factor
+      thumbnail_point.x = (target_width - scaled_width) * 0.5
     end
 
     # this is actually the interesting part:
 
-    UIGraphicsBeginImageContext(new_size)
+    UIGraphicsBeginImageContextWithOptions(new_size, false, self.scale)
+
+    if background
+      background = background.uicolor
+      context = UIGraphicsGetCurrentContext()
+      background.setFill
+      CGContextAddRect(context, [[0, 0], new_size])
+      CGContextDrawPath(context, KCGPathFill)
+    end
 
     thumbnail_rect = CGRectZero
     thumbnail_rect.origin = thumbnail_point
     thumbnail_rect.size.width  = scaled_width
     thumbnail_rect.size.height = scaled_height
 
-    sourceImage.drawInRect(thumbnail_rect)
+    self.drawInRect(thumbnail_rect)
 
     new_image = UIGraphicsGetImageFromCurrentImageContext()
     UIGraphicsEndImageContext()
@@ -96,8 +272,11 @@ class UIImage
     return new_image
   end
 
+  ##|
+  ##|  image modifications
+  ##|
   def rounded(corner_radius=5)
-    UIGraphicsBeginImageContext(size)
+    UIGraphicsBeginImageContextWithOptions(size, false, self.scale)
     path = UIBezierPath.bezierPathWithRoundedRect([[0, 0], size], cornerRadius:corner_radius)
     path.addClip
     self.drawInRect([[0, 0], size])
@@ -128,7 +307,7 @@ class UIImage
 
     context = CIContext.contextWithOptions(nil)
     cg_output_image = context.createCGImage(output, fromRect:output.extent)
-    output_image = UIImage.imageWithCGImage(cg_output_image)
+    output_image = UIImage.imageWithCGImage(cg_output_image, scale:self.scale, orientation:self.imageOrientation)
 
     return output_image
   end
@@ -156,7 +335,7 @@ class UIImage
     new_size = self.size
 
     # Create the bitmap context
-    UIGraphicsBeginImageContext(new_size)
+    UIGraphicsBeginImageContextWithOptions(new_size, false, self.scale)
     bitmap = UIGraphicsGetCurrentContext()
 
     # Move the origin to the middle of the image so we will rotate and scale around the center.
@@ -200,9 +379,11 @@ class UIImage
   ##|
   ##|  CGImageCreateWithMask
   ##|
-  ## The mask image cannot have ANY transparency.
-  ## Instead, transparent areas must be white or some value between black and white.
-  ## The closer towards black a pixel is the less transparent it becomes.
+  # The mask image cannot have ANY transparency. Instead, transparent areas must
+  # be white or some value between black and white. The more white a pixel is
+  # the more transparent it becomes.
+  #     black  .. white
+  #     opaque .. transparent
   def masked(mask_image)
     mask_image = mask_image.CGImage
 
@@ -217,7 +398,58 @@ class UIImage
       pixel_bits, row_bytes, data_provider,nil, false)
 
     masked = CGImageCreateWithMask(self.CGImage, mask)
-    UIImage.imageWithCGImage(masked)
+    UIImage.imageWithCGImage(masked, scale:self.scale, orientation:self.imageOrientation)
+  end
+
+  # Oddly enough, this method doesn't seem to have retina support
+  def color_at(point)
+    point = SugarCube::CoreGraphics::Point(point)
+    point.x *= self.scale
+    point.y *= self.scale
+
+    # First get the image into your data buffer
+    cgimage = self.CGImage
+    width = CGImageGetWidth(cgimage)
+    height = CGImageGetHeight(cgimage)
+    bytes_per_pixel = 4
+    bits_per_component = 8
+    bytes_per_row = bytes_per_pixel * width
+    @raw_data || begin
+      color_space = CGColorSpaceCreateDeviceRGB()
+      @raw_data = Pointer.new(:uchar, height * width * 4)
+      context = CGBitmapContextCreate(@raw_data, width, height, bits_per_component, bytes_per_row, color_space, KCGImageAlphaPremultipliedLast | KCGBitmapByteOrder32Big)
+
+      CGContextDrawImage(context, CGRectMake(0, 0, width, height), cgimage)
+    end
+
+    # Now @raw_data contains the image data in the RGBA8888 pixel format.
+    xx = point.x.round
+    yy = point.y.round
+    byte_index = (bytes_per_row * yy) + xx * bytes_per_pixel
+    red = @raw_data[byte_index]
+    green = @raw_data[byte_index + 1]
+    blue = @raw_data[byte_index + 2]
+    alpha = @raw_data[byte_index + 3]
+    return [red, green, blue].uicolor(alpha / 255.0)
+  end
+
+  def at_scale(scale)
+    if scale == self.scale
+      return self
+    end
+
+    new_size = self.size
+    new_size.width = new_size.width * self.scale / scale
+    new_size.height = new_size.height * self.scale / scale
+
+    UIGraphicsBeginImageContextWithOptions(new_size, false, scale)
+    thumbnail_rect = CGRect.new([0, 0], new_size)
+
+    self.drawInRect(thumbnail_rect)
+
+    new_image = UIGraphicsGetImageFromCurrentImageContext()
+    UIGraphicsEndImageContext()
+    return new_image
   end
 
 end

data/lib/sugarcube/uiview.rb

@@ -182,10 +182,23 @@ class UIView
     f = self.frame
     delta = SugarCube::CoreGraphics::Point(delta)
     position = SugarCube::CoreGraphics::Point(f.origin)
-    move_to(position + delta, options, &after)
+    to_position = CGPoint.new(position.x + delta.x, position.y + delta.y)
+    move_to(to_position, options, &after)
     self
   end
 
+  def rotate_to(options={}, &after)
+    if options.is_a? Numeric
+      options = { angle: options }
+    end
+
+    options[:after] ||= after
+
+    animate(options) {
+      self.transform = CGAffineTransformMakeRotation(options[:angle])
+    }
+  end
+
   def slide(direction, options={}, &after)
     if options.is_a? Numeric
       options = {size: options}

data/lib/sugarcube/version.rb

@@ -1,3 +1,3 @@
 module SugarCube
-  Version = '0.14.0'
+  Version = '0.15.0'
 end

data/lib/sugarcube-568/uiimage.rb

@@ -0,0 +1,32 @@
+class UIImage
+  class << self
+    SugarCube568_TallSuffix = '-568h@2x'
+
+    def imageNamed568(name)
+      @may_use_taller_images ||= CGSizeEqualToSize(CGSizeMake(320, 568), UIScreen.mainScreen.bounds.size)
+      if ( @may_use_taller_images && name.length > 0  && name.rangeOfString(SugarCube568_TallSuffix).location == NSNotFound )
+        # Check if is there a path extension or not
+        test_name = name;
+        if test_name.pathExtension.length > 0
+          test_name = test_name.stringByDeletingPathExtension.stringByAppendingString(SugarCube568_TallSuffix).stringByAppendingPathExtension(name.pathExtension)
+        else
+          test_name = test_name.stringByAppendingString(SugarCube568_TallSuffix + ".png")
+        end
+
+        image = imageNamed_old(test_name)
+        if image
+          return self.imageWithCGImage(image.CGImage, scale:2.0, orientation:image.imageOrientation)
+        end
+      end
+
+      return nil
+    end
+
+    alias :imageNamed_old :imageNamed
+# now we've got imageNamed568 and imageNamed_old to load the respective versions
+
+    def imageNamed(name)
+      imageNamed568(name) || imageNamed_old(name)
+    end
+  end
+end

data/lib/sugarcube-568.rb

@@ -0,0 +1,23 @@
+unless defined?(Motion::Project::Config)
+  raise "The sugarcube gem must be required within a RubyMotion project Rakefile."
+end
+
+
+Motion::Project::App.setup do |app|
+  # scans app.files until it finds app/ (the default)
+  # if found, it inserts just before those files, otherwise it will insert to
+  # the end of the list
+  insert_point = 0
+  app.files.each_index do |index|
+    file = app.files[index]
+    if file =~ /^(?:\.\/)?app\//
+      # found app/, so stop looking
+      break
+    end
+    insert_point = index + 1
+  end
+
+  Dir.glob(File.join(File.dirname(__FILE__), 'sugarcube-568/**/*.rb')).reverse.each do |file|
+    app.files.insert(insert_point, file)
+  end
+end

data/spec/568_spec.rb

@@ -0,0 +1,6 @@
+describe "568" do
+  it "should load 568h images" do
+    image = 'tall'.uiimage
+    image.size.height.should == UIScreen.mainScreen.bounds.size.height
+  end
+end

data/spec/calayer_spec.rb

@@ -0,0 +1,10 @@
+describe "CALayer" do
+
+  it "should support <<" do
+    layer = CALayer.layer
+    another_layer = CALayer.layer
+    layer << another_layer
+    layer.sublayers.should == [another_layer]
+  end
+
+end

data/spec/core_location_spec.rb

@@ -0,0 +1,15 @@
+describe "CoreLocation" do
+  before do
+    @denver = CLLocationCoordinate2D.new(39.764032, -104.963112)
+    @cincinnati = CLLocationCoordinate2D.new(39.267024, -84.251736)
+  end
+
+  it "should calculate distance in miles" do
+    @denver.distance_to(@cincinnati).miles.round.should == 1101
+  end
+
+  it "should calculate distance in kilometers" do
+    @denver.distance_to(@cincinnati).kilometers.round.should == 1772
+  end
+
+end

data/spec/symbol_uicolor_spec.rb

@@ -1,10 +1,24 @@
 describe 'Symbol#uicolor' do
 
   it "should return css color names" do
+    except_for = [:aqua, :fuchsia, :lime]
     Symbol.css_colors.each do |name, val|
+      next if except_for.include? name
+
       color = val.uicolor
       color.to_s.should == "UIColor.color(#{name.inspect})"
     end
   end
 
+  it "should return UIColor objects" do
+    Symbol.uicolors.each do |name, method|
+      name.uicolor.should == UIColor.send(method)
+    end
+    Symbol.css_colors.each do |name, val|
+      name.uicolor.is_a?(UIColor).should == true
+    end
+  end
+
+
+
 end

data/spec/uicolor_components_spec.rb

@@ -0,0 +1,33 @@
+describe "UIColor component methods" do
+  before do
+    @black = UIColor.blackColor
+    @gray = UIColor.grayColor
+    @white = UIColor.whiteColor
+    @some_color = UIColor.colorWithRed(0.6, green: 0.4, blue: 0.5, alpha:1.0)
+  end
+
+  it "should return 1,1,1 for white" do
+    @white.red.should == 1
+    @white.green.should == 1
+    @white.blue.should == 1
+  end
+
+  it "should return 0,0,0 for black" do
+    @black.red.should == 0
+    @black.green.should == 0
+    @black.blue.should == 0
+  end
+
+  it "should return 0.5,0.5,0.5 for gray" do
+    @gray.red.should == 0.5
+    @gray.green.should == 0.5
+    @gray.blue.should == 0.5
+  end
+
+  it "should return correct rgb for some_color" do
+    @some_color.red.should == 0.6
+    @some_color.green.should == 0.4
+    @some_color.blue.should == 0.5
+  end
+
+end

data/spec/uiimage_color_at_spec.rb

@@ -0,0 +1,59 @@
+describe "UIImage#color_at" do
+  before do
+    @image = 'little_square'.uiimage
+  end
+
+  describe "should return white at the corners" do
+    it "top_left" do
+      color = @image.color_at([0, 0])
+      color.red.should == 1
+      color.green.should == 1
+      color.blue.should == 1
+    end
+    it "top_right" do
+      color = @image.color_at([9, 0])
+      color.red.should == 1
+      color.green.should == 1
+      color.blue.should == 1
+    end
+    it "bottom_left" do
+      color = @image.color_at([0, 9])
+      color.red.should == 1
+      color.green.should == 1
+      color.blue.should == 1
+    end
+    it "bottom_right" do
+      color = @image.color_at([9, 9])
+      color.red.should == 1
+      color.green.should == 1
+      color.blue.should == 1
+    end
+  end
+
+  describe "should return blue at the center" do
+    it "3,3" do
+      color = @image.color_at([3, 3])
+      color.red.should == 0
+      color.green.should == 0
+      color.blue.should == 1
+    end
+    it "4,4" do
+      color = @image.color_at([4, 4])
+      color.red.should == 0
+      color.green.should == 0
+      color.blue.should == 1
+    end
+    it "5,5" do
+      color = @image.color_at([5, 5])
+      color.red.should == 0
+      color.green.should == 0
+      color.blue.should == 1
+    end
+    it "6,6" do
+      color = @image.color_at([6, 6])
+      color.red.should == 0
+      color.green.should == 0
+      color.blue.should == 1
+    end
+  end
+end

data/spec/uiimage_scale_spec.rb

@@ -0,0 +1,90 @@
+describe "UIImage scale methods" do
+  before do
+    @image = 'little_square'.uiimage
+  end
+
+  it 'should scale_to a wider size' do
+    scaled = @image.scale_to([20, 10])
+    scaled.nsdata.writeToFile('scale_to.png'.document, atomically: true)
+    scaled.size.width.should == 20
+    scaled.size.height.should == 10
+  end
+
+  it 'should scale_to a taller size' do
+    scaled = @image.scale_to([10, 20])
+    scaled.nsdata.writeToFile('scale_to.png'.document, atomically: true)
+    scaled.size.width.should == 10
+    scaled.size.height.should == 20
+  end
+
+  it 'scale_to should support background' do
+    scaled = @image.scale_to([20, 10], background: :blue.uicolor)
+    scaled.nsdata.writeToFile('scale_to_background.png'.document, atomically: true)
+    scaled.size.width.should == 20
+    scaled.size.height.should == 10
+  end
+
+  it 'should scale_within a smaller size' do
+    scaled = @image.scale_within([5, 10])
+    scaled.nsdata.writeToFile('scale_within_smaller.png'.document, atomically: true)
+    scaled.size.width.should == 5
+    scaled.size.height.should == 5
+  end
+
+  it 'should scale_within a bigger size' do
+    scaled = @image.scale_within([15, 20])
+    scaled.nsdata.writeToFile('scale_within_bigger.png'.document, atomically: true)
+    scaled.size.width.should == 15
+    scaled.size.height.should == 15
+  end
+
+  it 'should scale_to_fill a wider size' do
+    scaled = @image.scale_to_fill([20, 10])
+    scaled.nsdata.writeToFile('scale_to_fill.png'.document, atomically: true)
+    scaled.size.width.should == 20
+    scaled.size.height.should == 10
+    scaled.scale.should == @image.scale
+  end
+
+  it 'scale_to_fill should support position' do
+    scaled = @image.scale_to_fill([10, 20], position: :top_left)
+    scaled.nsdata.writeToFile('scale_to_fill_position_top_left.png'.document, atomically: true)
+    scaled = @image.scale_to_fill([20, 10], position: :top)
+    scaled.nsdata.writeToFile('scale_to_fill_position_top.png'.document, atomically: true)
+    scaled = @image.scale_to_fill([10, 20], position: :top_right)
+    scaled.nsdata.writeToFile('scale_to_fill_position_top_right.png'.document, atomically: true)
+    scaled = @image.scale_to_fill([10, 20], position: :left)
+    scaled.nsdata.writeToFile('scale_to_fill_position_left.png'.document, atomically: true)
+    scaled = @image.scale_to_fill([20, 10], position: :center)
+    scaled.nsdata.writeToFile('scale_to_fill_position_center.png'.document, atomically: true)
+    scaled = @image.scale_to_fill([10, 20], position: :right)
+    scaled.nsdata.writeToFile('scale_to_fill_position_right.png'.document, atomically: true)
+    scaled = @image.scale_to_fill([10, 20], position: :bottom_left)
+    scaled.nsdata.writeToFile('scale_to_fill_position_bottom_left.png'.document, atomically: true)
+    scaled = @image.scale_to_fill([20, 10], position: :bottom)
+    scaled.nsdata.writeToFile('scale_to_fill_position_bottom.png'.document, atomically: true)
+    scaled = @image.scale_to_fill([10, 20], position: :bottom_right)
+    scaled.nsdata.writeToFile('scale_to_fill_position_bottom_right.png'.document, atomically: true)
+    scaled.size.width.should == 10
+    scaled.size.height.should == 20
+  end
+
+  it 'should be able to change scale' do
+    if UIScreen.mainScreen.scale == 2
+      scaled = @image.at_scale(1.0)
+      scaled.nsdata.writeToFile('at_scale.png'.document, atomically: true)
+
+      scaled.size.width.should == 20
+      scaled.size.height.should == 20
+      scaled.scale.should == 1
+    else
+      scaled = @image.at_scale(2.0)
+      scaled.nsdata.writeToFile('at_scale.png'.document, atomically: true)
+
+      scaled.size.width.should == 5
+      scaled.size.height.should == 5
+      scaled.scale.should == 2
+    end
+  end
+
+end

data/spec/uiview_animation_spec.rb

@@ -0,0 +1,16 @@
+describe "UIView animation methods" do
+  before do
+    @view = UIView.alloc.initWithFrame([[1,2],[3,4]])
+  end
+
+  it 'should delta_to x:1 y:2' do
+    @view.delta_to([1,2]).frame.should == CGRectMake(2,4,3,4)
+  end
+  
+  it 'should rotate 45 degrees' do
+    angle = 45*Math::PI/180
+    @view.rotate_to(angle)
+    current_angle =  Math.atan2(@view.transform.b, @view.transform.a)
+    current_angle.should == angle
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: sugarcube
 version: !ruby/object:Gem::Version
-  version: 0.14.0
+  version: 0.15.0
   prerelease: 
 platform: ruby
 authors:
@@ -13,7 +13,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-01-15 00:00:00.000000000 Z
+date: 2013-01-29 00:00:00.000000000 Z
 dependencies: []
 description: ! '== Description
 
@@ -48,6 +48,8 @@ files:
 - README.md
 - Rakefile
 - app/app_delegate.rb
+- lib/sugarcube-568.rb
+- lib/sugarcube-568/uiimage.rb
 - lib/sugarcube-gestures.rb
 - lib/sugarcube-gestures/gestures.rb
 - lib/sugarcube.rb
@@ -103,9 +105,24 @@ files:
 - lib/sugarcube/uiviewcontroller.rb
 - lib/sugarcube/uuid.rb
 - lib/sugarcube/version.rb
+- resources/Default-568h@2x.png
+- resources/Default.png
+- resources/Default@2x.png
+- resources/little_square.png
+- resources/little_square@2x.png
+- resources/tall-568h@2x.png
+- resources/tall.png
+- resources/tall@2x.png
+- spec/568_spec.rb
+- spec/calayer_spec.rb
 - spec/core_graphics_spec.rb
+- spec/core_location_spec.rb
 - spec/nsstring_files_spec.rb
 - spec/symbol_uicolor_spec.rb
+- spec/uicolor_components_spec.rb
+- spec/uiimage_color_at_spec.rb
+- spec/uiimage_scale_spec.rb
+- spec/uiview_animation_spec.rb
 - sugarcube.gemspec
 homepage: https://github.com/rubymotion/sugarcube
 licenses: []
@@ -133,7 +150,14 @@ specification_version: 3
 summary: Extensions for Ruby to make Rubymotion development more enjoyable, and hopefully
   more rubyesque!
 test_files:
+- spec/568_spec.rb
+- spec/calayer_spec.rb
 - spec/core_graphics_spec.rb
+- spec/core_location_spec.rb
 - spec/nsstring_files_spec.rb
 - spec/symbol_uicolor_spec.rb
+- spec/uicolor_components_spec.rb
+- spec/uiimage_color_at_spec.rb
+- spec/uiimage_scale_spec.rb
+- spec/uiview_animation_spec.rb
 has_rdoc: