Merge pull request #357 from knickmack/feature/324-readme-swift-usage

Add Swift usage examples to README.md

Author: Adam Bell

README.md

@@ -1,6 +1,6 @@
 ![pop](https://github.com/facebook/pop/blob/master/Images/pop.gif?raw=true)
 
-Pop is an extensible animation engine for iOS, tvOS, and OS X. In addition to basic static animations, it supports spring and decay dynamic animations, making it useful for building realistic, physics-based interactions. The API allows quick integration with existing Objective-C codebases and enables the animation of any property on any object. It's a mature and well-tested framework that drives all the animations and transitions in [Paper](http://www.facebook.com/paper).
+Pop is an extensible animation engine for iOS, tvOS, and OS X. In addition to basic static animations, it supports spring and decay dynamic animations, making it useful for building realistic, physics-based interactions. The API allows quick integration with existing Objective-C or Swift codebases and enables the animation of any property on any object. It's a mature and well-tested framework that drives all the animations and transitions in [Paper](http://www.facebook.com/paper).
 
 [![Build Status](https://travis-ci.org/facebook/pop.svg)](https://travis-ci.org/facebook/pop)
 
@@ -34,6 +34,8 @@ Alternatively, you can add the project to your workspace and adopt the provided
 
 Pop adopts the Core Animation explicit animation programming model. Use by including the following import:
 
+#### Objective-C
+
 ```objective-c
 #import <pop/POP.h>
 ```
@@ -44,24 +46,50 @@ or if you're using the embedded framework:
 @import pop;
 ```
 
+#### Swift
+
+```swift
+import pop
+```
+
 ### Start, Stop & Update
 
 To start an animation, add it to the object you wish to animate:
 
+#### Objective-C
+
 ```objective-c
 POPSpringAnimation *anim = [POPSpringAnimation animation];
 ...
 [layer pop_addAnimation:anim forKey:@"myKey"];
 ```
 
+#### Swift
+
+```swift
+let anim = POPSpringAnimation()
+...
+layer.pop_add(anim, forKey: "myKey")
+```
+
 To stop an animation, remove it from the object referencing the key specified on start:
 
+#### Objective-C
+
 ```objective-c
 [layer pop_removeAnimationForKey:@"myKey"];
 ```
 
+#### Swift
+
+```swift
+layer.pop_removeAnimation(forKey: "myKey")
+```
+
 The key can also be used to query for the existence of an animation. Updating the toValue of a running animation can provide the most seamless way to change course:
 
+#### Objective-C
+
 ```objective-c
 anim = [layer pop_animationForKey:@"myKey"];
 if (anim) {
@@ -73,6 +101,18 @@ if (anim) {
 }
 ```
 
+#### Swift
+
+```swift
+if let anim = layer.pop_animation(forKey: "myKey") as? POPSpringAnimation {
+    /* update to value to new destination */
+    anim.toValue = 42.0
+} else {
+    /* create and start a new animation */
+    ....
+}
+```
+
 While a layer was used in the above examples, the Pop interface is implemented as a category addition on NSObject. Any NSObject or subclass can be animated.
 
 ### Types
@@ -81,41 +121,92 @@ There are four concrete animation types: spring, decay, basic and custom.
 
 Spring animations can be used to give objects a delightful bounce. In this example, we use a spring animation to animate a layer's bounds from its current value to (0, 0, 400, 400):
 
+#### Objective-C
+
 ```objective-c
 POPSpringAnimation *anim = [POPSpringAnimation animationWithPropertyNamed:kPOPLayerBounds];
 anim.toValue = [NSValue valueWithCGRect:CGRectMake(0, 0, 400, 400)];
 [layer pop_addAnimation:anim forKey:@"size"];
 ```
+
+#### Swift
+
+```swift
+if let anim = POPSpringAnimation(propertyNamed: kPOPLayerBounds) {
+    anim.toValue = NSValue(cgRect: CGRect(x: 0, y: 0, width: 400, height: 400))
+    layer.pop_add(anim, forKey: "size")
+}
+```
+
 Decay animations can be used to gradually slow an object to a halt. In this example, we decay a layer's positionX from it's current value and velocity 1000pts per second:
 
+#### Objective-C
+
 ```objective-c
 POPDecayAnimation *anim = [POPDecayAnimation animationWithPropertyNamed:kPOPLayerPositionX];
 anim.velocity = @(1000.);
 [layer pop_addAnimation:anim forKey:@"slide"];
 ```
 
+#### Swift
+
+```swift
+if let anim = POPDecayAnimation(propertyNamed: kPOPLayerPositionX) {
+    anim.velocity = 1000.0
+    layer.pop_add(anim, forKey: "slide")
+}
+```
+
 Basic animations can be used to interpolate values over a specified time period. To use an ease-in ease-out animation to animate a view's alpha from 0.0 to 1.0 over the default duration:
+
+#### Objective-C
+
 ```objective-c
 POPBasicAnimation *anim = [POPBasicAnimation animationWithPropertyNamed:kPOPViewAlpha];
 anim.timingFunction = [CAMediaTimingFunction functionWithName:kCAMediaTimingFunctionEaseInEaseOut];
 anim.fromValue = @(0.0);
 anim.toValue = @(1.0);
 [view pop_addAnimation:anim forKey:@"fade"];
 ```
+
+#### Swift
+
+```swift
+if let anim = POPBasicAnimation(propertyNamed: kPOPViewAlpha) {
+    anim.timingFunction = CAMediaTimingFunction(name: kCAMediaTimingFunctionEaseInEaseOut)
+    anim.fromValue = 0.0
+    anim.toValue = 1.0
+    view.pop_add(anim, forKey: "fade")
+}
+```
+
 `POPCustomAnimation` makes creating custom animations and transitions easier by handling CADisplayLink and associated time-step management. See header for more details.
 
 
 ### Properties
 
 The property animated is specified by the `POPAnimatableProperty` class. In this example we create a spring animation and explicitly set the animatable property corresponding to `-[CALayer bounds]`:
 
+#### Objective-C
+
 ```objective-c
 POPSpringAnimation *anim = [POPSpringAnimation animation];
 anim.property = [POPAnimatableProperty propertyWithName:kPOPLayerBounds];
 ```
 
+#### Swift
+
+```swift
+let anim = POPSpringAnimation()
+if let property = POPAnimatableProperty.property(withName: kPOPLayerBounds) as? POPAnimatableProperty {
+    anim.property = property
+}
+```
+
 The framework provides many common layer and view animatable properties out of box. You can animate a custom property by creating a new instance of the class. In this example, we declare a custom volume property:
 
+#### Objective-C
+
 ```objective-c
 prop = [POPAnimatableProperty propertyWithName:@"com.foo.radio.volume" initializer:^(POPMutableAnimatableProperty *prop) {
   // read value
@@ -133,6 +224,36 @@ prop = [POPAnimatableProperty propertyWithName:@"com.foo.radio.volume" initializ
 anim.property = prop;
 ```
 
+#### Swift
+
+```swift
+if let prop = POPAnimatableProperty.property(withName: "com.foo.radio.volume", initializer: { prop in
+    guard let prop = prop else {
+        return
+    }
+    // read value
+    prop.readBlock = { obj, values in
+        guard let obj = obj as? Volumeable, let values = values else {
+            return
+        }
+
+        values[0] = obj.volume
+    }
+    // write value
+    prop.writeBlock = { obj, values in
+        guard var obj = obj as? Volumeable, let values = values else {
+            return
+        }
+
+        obj.volume = values[0]
+    }
+    // dynamics threshold
+    prop.threshold = 0.01
+}) as? POPAnimatableProperty {
+    anim.property = prop
+}
+```
+
 For a complete listing of provided animatable properties, as well more information on declaring custom properties see `POPAnimatableProperty.h`.
 
 
@@ -142,18 +263,37 @@ Here are a few tips when debugging. Pop obeys the Simulator's Toggle Slow Animat
 
 Consider naming your animations. This will allow you to more easily identify them when referencing them, either via logging or in the debugger:
 
+#### Objective-C
+
 ```objective-c
 anim.name = @"springOpen";
 ```
 
+#### Swift
+
+```swift
+anim.name = "springOpen"
+```
+
 Each animation comes with an associated tracer. The tracer allows you to record all animation-related events, in a fast and efficient manner, allowing you to query and analyze them after animation completion. The below example starts the tracer and configures it to log all events on animation completion:
 
+#### Objective-C
+
 ```objective-c
 POPAnimationTracer *tracer = anim.tracer;
 tracer.shouldLogAndResetOnCompletion = YES;
 [tracer start];
 ```
 
+#### Swift
+
+```swift
+if let tracer = anim.tracer {
+    tracer.shouldLogAndResetOnCompletion = true
+    tracer.start()
+}
+```
+
 See `POPAnimationTracer.h` for more details.
 
 ## Testing