sugarcube 1.1.0 → 1.3.0

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    sugarcube (1.1.0)
+    sugarcube (1.3.0)
 
 GEM
   remote: https://rubygems.org/

data/README.md

@@ -171,8 +171,9 @@ A big package chock full of methods to make working in UIKit a joy.
 A few varieties of methods are in this package:
 
 * Conversions: `'string-to'.uiimage`, `image.uiimageview`
-* Helpers: shorthands for common operations, like `a_view << a_subview`
+* Helpers: shorthands for common operations, like `a_view << a_subview`, `a_subview.convert_frame_to(a_view)`
 * Symbols: `:system.uifont(20)`, `:label.uifontsize`
+* Frame accessors: `a_view.x`, `a_view.x = 100`
 
 There are too many methods to define here. Instead: a complete list of methods
 is available in the [documentation][], and the [wiki page][UIKit Wiki] is a
@@ -451,8 +452,22 @@ image.stretchable(insets)
 # will be made transparent, and black opaque.
 image.masked(mask_image)
 
+# Apply a color overlay to an image. This is used used on icons (PNG's), on which
+# you want to change the color.
+image.overlay(UIColor.redColor)
+image.overlay(:red)
+
 # Combine two images
 image_ab = image_a << image_b
+
+# Create an image from scratch!
+UIImage.canvas([100, 100]) do |context|  # opaque: false, scale: UIScreen.mainScreen.scale
+  # draw here!
+end
+# use an image as a background to draw on
+image.draw do |context|
+  # draw here!
+end
 ```
 
 ###### CIFilter additions
@@ -546,6 +561,15 @@ These methods are added onto the UIColor class:
 :white.uicolor.mix_with(:black.uicolor, 0.75)  # => 0xbfbfbf.uicolor
 :white.uicolor.mix_with(:black.uicolor, 1)  # => :black
 
+# you can get information about a color:
+:cyan.uicolor.red         # => 0
+:cyan.uicolor.green       # => 1
+:cyan.uicolor.blue        # => 1
+:cyan.uicolor.hue         # => 0.5
+:cyan.uicolor.saturation  # => 1.0
+:cyan.uicolor.brightness  # => 1.0
+:cyan.uicolor(0.9).alpha  # => 0.9
+
 # convert to CGColor
 color.cgcolor
 ```
@@ -796,8 +820,9 @@ view.tumble  # great way to dismiss an alert-like-view
 
 These helpers all delegate to the `UIView.animate` method, which accepts all the
 options that `UIView.animateWithDuration(delay:options:animations:completion:)`
-accepts, but they are optional, and they will play nicely inside an animation
-chain.
+or `UIView.animateWithDuration(delay:usingSpringWithDamping:initialSpringVelocity:options:animations:completion:)`
+accept.  All options are optional, and they will play nicely inside an animation
+chain (see below, and the wiki page).
 
 ```ruby
 UIView.animate do
@@ -805,6 +830,23 @@ UIView.animate do
 end
 ```
 
+The "spring" animations use the method `UIView.animateWithDuration(delay:usingSpringWithDamping:initialSpringVelocity:options:animations:completion:)`,
+available in iOS 7.  In testing, I've found this method to be slightly
+unreliable, so use with caution.  To "enable" it, pass in the `:damping` option.
+You can also use `:velocity` to set an initial velocity, if there is an
+animation in progress.
+
+```ruby
+new_frame = [[110, 200], [100, 20]]
+
+UIView.animate(damping: 0.1) do  # default velocity is 0
+  view.frame = new_frame
+end
+
+# equivalent:
+view.reframe_to(new_frame, damping: 0.1, velocity: 1)
+```
+
 The [wiki] page documents all the different animation methods, and documents
 animation chaining, which looks like this:
 
@@ -819,6 +861,14 @@ end.and_then do
 end.start
 ```
 
+Core Animation classes get some love, too!
+
+```ruby
+view.layer.basic_animation('opacity', from: 0, to: 1, duration: 0.1)
+```
+
+Lots more information in the Wiki!
+
 [Animations Wiki]: https://github.com/rubymotion/sugarcube/wiki/Animations
 
 Modal
@@ -947,6 +997,13 @@ e.g. 1024 bytes in a kilobyte.
 1.megabyte.in_kilobytes   # => 1024
 ```
 
+### Screen
+
+```ruby
+1.pixel  # => 1 on non-retina, 0.5 on retina.
+         # Useful when drawing if you want to specify the number of pixels
+```
+
 AttributedString
 -----
 
@@ -1113,8 +1170,8 @@ NSDate ([wiki][NSDate Wiki])
 > `require 'sugarcube-nsdate'`
 
 This package includes additions to the `NSDate` class, and related additions to
-`Fixnum` and `NSString`.  There's a lot here, so check out the [wiki][NSDate Wiki]
-for detailed information.
+`Numeric` and `NSString`.  There's a lot here, so check out the [wiki][NSDate
+Wiki] for detailed information.
 
 [NSDate Wiki]: https://github.com/rubymotion/sugarcube/wiki/NSDate
 
@@ -1314,20 +1371,26 @@ CoreLocation
 Open up `CLLocationCoordinate2D` to provide handy-dandies
 
 ```ruby
+# distances
+
 > denver_co = CLLocationCoordinate2D.new(39.739188,-104.985223)
 => #<CLLocationCoordinate2D latitude=39.7391815185547 longitude=-104.985198974609>
 > loveland_oh = CLLocationCoordinate2D.new(39.268128,-84.257648)
 => #<CLLocationCoordinate2D latitude=39.2681274414062 longitude=-84.2576293945312>
 > denver_co.distance_to(loveland_oh)
-=> 1773425.5  # in meters
+=> 1773425.54893302  # in meters
 > denver_co.distance_to(loveland_oh).in_miles
-=> 1101.955078125
+=> 1101.95556640625
+
+# move around the globe using x/y distances in miles or kilometers
 > denver_co.delta_miles(1101.6, -32.556)
 => #<CLLocationCoordinate2D latitude=39.2681427001953 longitude=-84.2577209472656>
-> denver_co.delta_miles(1101.6, -32.556).distance_to(loveland_oh)
-=> 8.0804328918457   # this is in meters
+# our location is pretty close!
 > denver_co.delta_miles(1101.6, -32.556).distance_to(loveland_oh).miles
-=> 0.00502094626426697
+=> 0.90043306350708
+
+> denver_co.delta_kilometers(10, 10)  # 10 kilometers east, 10 kilometers north
+=> #<CLLocationCoordinate2D latitude=39.8290100097656 longitude=-104.868377685547>
 ```
 
 Pipes

data/lib/sugarcube-animations/caanimation.rb

@@ -0,0 +1,31 @@
+class CAAnimation
+
+  class << self
+
+    def basic(target, key_path, options={}, &block)
+      corner_animation = CABasicAnimation.animationWithKeyPath(key_path)
+      corner_animation.duration = options[:duration] if options[:duration]
+      corner_animation.delegate = options[:delegate] if options[:delegate]
+
+      if options.key?(:from) || options.key?(:to) || options.key?(:by)
+        add_animation = options.fetch(:add, true)
+
+        corner_animation.fromValue = options[:from] if options[:from]
+        corner_animation.toValue = options[:to] if options[:to]
+        corner_animation.byValue = options[:by] if options[:by]
+      else
+        add_animation = options.fetch(:add, false)
+      end
+
+      if add_animation
+        target.addAnimation(corner_animation, forKey:key_path)
+        target.send("#{key_path}=", options[:to])
+      end
+
+      block.call(corner_animation) if block
+      return corner_animation
+    end
+
+  end
+
+end

data/lib/sugarcube-animations/calayer.rb

@@ -0,0 +1,7 @@
+class CALayer
+
+  def basic_animation(key_path, options={})
+    CAAnimation.basic(self, key_path, options)
+  end
+
+end

data/lib/sugarcube-animations/uiview.rb

@@ -5,18 +5,30 @@ class UIView
     # 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 animate(options={}, &animations)
+    # @option options [Float] :duration Animation duration. default: 0.3
+    # @option options [Float] :delay Delay before animations begin. default: 0
+    # @option options [Float] :damping Enables the "spring" animation.  Value of 1.0 is a stiff spring.
+    # @option options [Float] :velocity Used in a spring animation to set the initial velocity
+    # @option options [Proc]  :after A block that is executed when the animation is complete, useful for chaining (though the `animation_chain` method is better!)
+    # @option options [Fixnum] :options The options parameter that is passed to the UIView.animateWithDuration(...) method.  You can also use the more verbose options `:curve`, `:from_current`, and `:allow_interaction`
+    # @option options [Fixnum] :curve The animation curve option. default: UIViewAnimationOptionCurveEaseIn
+    # @option options [Boolean] :from_current Whether or not to have animations start from their current position (aka UIViewAnimationOptionBeginFromCurrentState)
+    # @option options [Boolean] :allow_interaction aka UIViewAnimationOptionAllowUserInteraction
+    def animate(options={}, more_options={}, &animations)
       raise "animation block is required" unless animations
 
       if options.is_a? Numeric
         duration = options
-        options = {}
+        options = more_options
       else
         duration = options[:duration] || 0.3
       end
 
       delay = options[:delay] || 0
 
+      damping_ratio = options[:damping] || nil
+      spring_velocity = options[:velocity] || 0.0
+
       # chain: true is used inside animation_chain blocks to prevent some weird
       # animation errors (nested animations do not delay/queue as you'd expect)
       if options[:chain] || Thread.current[:sugarcube_chaining]
@@ -47,18 +59,34 @@ class UIView
         animation_options = curve | from_current
       end
 
+
+
+
+
       if duration == 0 && delay == 0
         animations.call
         after_adjusted.call(true) if after_adjusted
       else
         prev_value = Thread.current[:sugarcube_chaining]
         Thread.current[:sugarcube_chaining] = true
-        UIView.animateWithDuration( duration,
-                             delay: delay,
-                           options: animation_options,
-                        animations: animations,
-                        completion: after_adjusted
-                                  )
+
+        if damping_ratio
+          UIView.animateWithDuration( duration,
+                               delay: delay,
+              usingSpringWithDamping: damping_ratio,
+               initialSpringVelocity: spring_velocity,
+                             options: animation_options,
+                          animations: animations,
+                          completion: after_adjusted
+                                    )
+        else
+          UIView.animateWithDuration( duration,
+                               delay: delay,
+                             options: animation_options,
+                          animations: animations,
+                          completion: after_adjusted
+                                    )
+        end
         Thread.current[:sugarcube_chaining] = prev_value
       end
       nil
@@ -87,12 +115,9 @@ class UIView
   end
 
   # Same as UIView##animate, but acts on self
-  def animate(options={}, &animations)
+  def animate(options={}, more_options={}, &animations)
     if options.is_a? Numeric
-      duration = options
-      options = {}
-    else
-      duration = options[:duration] || 0.3
+      options = more_options.merge(duration: options)
     end
 
     assign = options[:assign] || {}
@@ -108,7 +133,7 @@ class UIView
   end
 
   # Changes the layer opacity.
-  def fade(options={}, &after)
+  def fade(options={}, more_options={}, &after)
     if options.is_a? Numeric
       options = { opacity: options }
     end
@@ -122,9 +147,9 @@ class UIView
 
   # Changes the layer opacity to 0.
   # @see #fade
-  def fade_out(options={}, &after)
+  def fade_out(options={}, more_options={}, &after)
     if options.is_a? Numeric
-      options = { duration: options }
+      options = more_options.merge(duration: options)
     end
 
     options[:opacity] ||= 0.0
@@ -134,9 +159,9 @@ class UIView
 
   # Changes the layer opacity to 1.
   # @see #fade
-  def fade_in(options={}, &after)
+  def fade_in(options={}, more_options={}, &after)
     if options.is_a? Numeric
-      options = { duration: options }
+      options = more_options.merge(duration: options)
     end
 
     options[:opacity] ||= 1.0
@@ -146,9 +171,9 @@ class UIView
 
   # Changes the layer opacity to 0 and then removes the view from its superview
   # @see #fade_out
-  def fade_out_and_remove(options={}, &after)
+  def fade_out_and_remove(options={}, more_options={}, &after)
     if options.is_a? Numeric
-      options = { duration: options }
+      options = more_options.merge(duration: options)
     end
 
     original_opacity = self.alpha
@@ -162,9 +187,9 @@ class UIView
     fade_out(options, &after_remove)
   end
 
-  def move_to(position, options={}, &after)
+  def move_to(position, options={}, more_options={}, &after)
     if options.is_a? Numeric
-      options = { duration: options }
+      options = more_options.merge(duration: options)
     end
 
     options[:after] = after
@@ -176,18 +201,18 @@ class UIView
     end
   end
 
-  def delta_to(delta, options={}, &after)
+  def delta_to(delta, options={}, more_options={}, &after)
     f = self.frame
     delta = SugarCube::CoreGraphics::Point(delta)
     position = SugarCube::CoreGraphics::Point(f.origin)
     to_position = CGPoint.new(position.x + delta.x, position.y + delta.y)
-    move_to(to_position, options, &after)
+    move_to(to_position, options, more_options, &after)
     self
   end
 
-  def resize_to(size, options={}, &after)
+  def resize_to(size, options={}, more_options={}, &after)
     if options.is_a? Numeric
-      options = { duration: options }
+      options = more_options.merge(duration: options)
     end
 
     options[:after] = after
@@ -199,9 +224,9 @@ class UIView
     end
   end
 
-  def reframe_to(frame, options={}, &after)
+  def reframe_to(frame, options={}, more_options={}, &after)
     if options.is_a? Numeric
-      options = { duration: options }
+      options = more_options.merge(duration: options)
     end
 
     options[:after] = after
@@ -276,10 +301,10 @@ class UIView
   #   view.shake(offset: 0.1, repeat: 2, duration: 0.5, keypath: 'transform.rotation')
   #   # slow nodding
   #   view.shake(offset: 20, repeat: 10, duration: 5, keypath: 'transform.translation.y')
-  def shake(options={})
+  def shake(options={}, more_options={})
     if options.is_a? Numeric
       duration = options
-      options = {}
+      options = more_options
     else
       duration = options[:duration] || 0.3
     end
@@ -324,10 +349,10 @@ class UIView
   # Moves the view off screen while slowly rotating it.
   #
   # Based on https://github.com/warrenm/AHAlertView/blob/master/AHAlertView/AHAlertView.m
-  def tumble(options={}, &after)
+  def tumble(options={}, more_options={}, &after)
     if options.is_a? Numeric
       default_duration = options
-      options = {}
+      options = more_options
     else
       default_duration = 0.3
     end
@@ -366,7 +391,7 @@ class UIView
 
   # Moves the view backwards, similar to what Google has been doing a lot
   # recently
-  def back_fiend!(options={})
+  def back_fiend!(options={}, more_options={})
     scale = options[:scale] || 0.5
     perspective = options[:perspective] || -0.0005
     size = options[:size] || -140
@@ -379,7 +404,7 @@ class UIView
   end
 
   # restores the layer after a call to 'back_fiend!'
-  def forward_fiend!(options={})
+  def forward_fiend!(options={}, more_options={})
     UIView.animate(options) do
       self.layer.transform = CATransform3DIdentity
     end

data/lib/sugarcube-attributedstring/nsattributedstring.rb

@@ -53,6 +53,9 @@ class NSAttributedString
     foo = NSStrokeWidthAttributeName
     foo = NSShadowAttributeName
     foo = NSVerticalGlyphFormAttributeName
+    # new iOS 7 text effects
+    foo = NSTextEffectsAttributeName
+    foo = NSTextEffectsLetterPressStyle
     # make sure alignments get compiled
     foo = NSLeftTextAlignment
     foo = NSRightTextAlignment
@@ -130,6 +133,10 @@ class NSAttributedString
     with_attributes({NSVerticalGlyphFormAttributeName => value})
   end
 
+  def letterpress
+    with_attributes({NSTextEffectsAttributeName => NSTextEffectsLetterPressStyle})
+  end
+
   def with_attributes(attributes)
     retval = NSMutableAttributedString.alloc.initWithAttributedString(self)
     retval.addAttributes(attributes, range:[0, self.length])

data/lib/sugarcube-color/nsstring.rb

@@ -9,7 +9,7 @@ class NSString
       return self[1..-1].to_i(16).uicolor(alpha)
     end
 
-    img = self.uiimage
+    img = UIImage.imageNamed(self)
     img && img.uicolor(alpha)
   end