development: refactors Animation class

Sources/iOS/Animation.swift

@@ -57,20 +57,21 @@ public func AnimationFillModeToValue(mode: AnimationFillMode) -> String {
 
 
 @objc(AnimationTimingFunction)
 @objc(AnimationTimingFunction)
 public enum AnimationTimingFunction: Int {
 public enum AnimationTimingFunction: Int {
-    case liner
+    case linear
     case easeIn
     case easeIn
     case easeOut
     case easeOut
     case easeInEaseOut
     case easeInEaseOut
-    case systemDefault
+    case `default`
 }
 }
 
 
 /**
 /**
  Converts the AnimationTimingFunction enum value to a corresponding CAMediaTimingFunction.
  Converts the AnimationTimingFunction enum value to a corresponding CAMediaTimingFunction.
  - Parameter function: An AnimationTimingFunction enum value.
  - Parameter function: An AnimationTimingFunction enum value.
+ - Returns: A CAMediaTimingFunction.
  */
  */
 public func AnimationTimingFunctionToValue(function: AnimationTimingFunction) -> CAMediaTimingFunction {
 public func AnimationTimingFunctionToValue(function: AnimationTimingFunction) -> CAMediaTimingFunction {
     switch function {
     switch function {
-    case .liner:
+    case .linear:
         return CAMediaTimingFunction(name: kCAMediaTimingFunctionLinear)
         return CAMediaTimingFunction(name: kCAMediaTimingFunctionLinear)
     case .easeIn:
     case .easeIn:
         return CAMediaTimingFunction(name: kCAMediaTimingFunctionEaseIn)
         return CAMediaTimingFunction(name: kCAMediaTimingFunctionEaseIn)
@@ -78,18 +79,23 @@ public func AnimationTimingFunctionToValue(function: AnimationTimingFunction) ->
         return CAMediaTimingFunction(name: kCAMediaTimingFunctionEaseOut)
         return CAMediaTimingFunction(name: kCAMediaTimingFunctionEaseOut)
     case .easeInEaseOut:
     case .easeInEaseOut:
         return CAMediaTimingFunction(name: kCAMediaTimingFunctionEaseInEaseOut)
         return CAMediaTimingFunction(name: kCAMediaTimingFunctionEaseInEaseOut)
-    case .systemDefault:
+    case .default:
         return CAMediaTimingFunction(name: kCAMediaTimingFunctionDefault)
         return CAMediaTimingFunction(name: kCAMediaTimingFunctionDefault)
     }
     }
 }
 }
 
 
-
 public typealias AnimationDelayCancelBlock = (Bool) -> Void
 public typealias AnimationDelayCancelBlock = (Bool) -> Void
 
 
 public struct Animation {
 public struct Animation {
-	/// Delay helper method.
+	/**
+     Executes a block of code after a time delay.
+     - Parameter duration: An animation duration time.
+     - Parameter animations: An animation block.
+     - Parameter execute block: A completion block that is executed once
+     the animations have completed.
+     */
     @discardableResult
     @discardableResult
-    public static func delay(time: TimeInterval, completion: @escaping () -> Void) -> AnimationDelayCancelBlock? {
+    public static func delay(time: TimeInterval, execute block: @escaping () -> Void) -> AnimationDelayCancelBlock? {
 		
 		
 		func asyncAfter(completion: @escaping () -> Void) {
 		func asyncAfter(completion: @escaping () -> Void) {
 			DispatchQueue.main.asyncAfter(deadline: DispatchTime.now() + time, execute: completion)
 			DispatchQueue.main.asyncAfter(deadline: DispatchTime.now() + time, execute: completion)
@@ -97,10 +103,11 @@ public struct Animation {
 		
 		
 		var cancelable: AnimationDelayCancelBlock?
 		var cancelable: AnimationDelayCancelBlock?
 		
 		
-		let delayed: AnimationDelayCancelBlock = { (cancel) in
-			if !cancel {
-				DispatchQueue.main.async(execute: completion)
+		let delayed: AnimationDelayCancelBlock = {
+			if !$0 {
+				DispatchQueue.main.async(execute: block)
 			}
 			}
+            
 			cancelable = nil
 			cancelable = nil
 		}
 		}
 		
 		
@@ -114,24 +121,30 @@ public struct Animation {
 	}
 	}
 	
 	
 	/**
 	/**
-	:name:	delayCancel
-	*/
-	public static func delayCancel(completion: AnimationDelayCancelBlock) {
+     Cancels the delayed AnimationDelayCancelBlock.
+     - Parameter delayed completion: An AnimationDelayCancelBlock.
+     */
+	public static func cancel(delayed completion: AnimationDelayCancelBlock) {
 		completion(true)
 		completion(true)
 	}
 	}
 
 
 	
 	
 	/**
 	/**
-	:name:	animationDisabled
-	*/
-	public static func animationDisabled(animations: (() -> Void)) {
-		animateWithDuration(duration: 0, animations: animations)
+     Disables the default animations set on CALayers. 
+     - Parameter animations: A callback that wraps the animations to disable.
+     */
+	public static func disable(animations: (() -> Void)) {
+		animate(duration: 0, animations: animations)
 	}
 	}
 	
 	
 	/**
 	/**
-	:name:	animateWithDuration
-	*/
-	public static func animateWithDuration(duration: CFTimeInterval, animations: (() -> Void), completion: (() -> Void)? = nil) {
+     Runs an animation with a specified duration.
+     - Parameter duration: An animation duration time.
+     - Parameter animations: An animation block.
+     - Parameter completion: A completion block that is executed once
+     the animations have completed.
+     */
+	public static func animate(duration: CFTimeInterval, animations: (() -> Void), completion: (() -> Void)? = nil) {
 		CATransaction.begin()
 		CATransaction.begin()
 		CATransaction.setAnimationDuration(duration)
 		CATransaction.setAnimationDuration(duration)
 		CATransaction.setCompletionBlock(completion)
 		CATransaction.setCompletionBlock(completion)
@@ -141,9 +154,12 @@ public struct Animation {
 	}
 	}
 	
 	
 	/**
 	/**
-	:name:	animationGroup
-	*/
-	public static func animationGroup(animations: [CAAnimation], duration: CFTimeInterval = 0.5) -> CAAnimationGroup {
+     Creates a CAAnimationGroup.
+     - Parameter animations: An Array of CAAnimation objects.
+     - Parameter duration: An animation duration time for the group.
+     - Returns: A CAAnimationGroup.
+     */
+	public static func animate(group animations: [CAAnimation], duration: CFTimeInterval = 0.5) -> CAAnimationGroup {
 		let group: CAAnimationGroup = CAAnimationGroup()
 		let group: CAAnimationGroup = CAAnimationGroup()
 		group.fillMode = AnimationFillModeToValue(mode: .forwards)
 		group.fillMode = AnimationFillModeToValue(mode: .forwards)
 		group.isRemovedOnCompletion = false
 		group.isRemovedOnCompletion = false
@@ -154,11 +170,16 @@ public struct Animation {
 	}
 	}
 	
 	
 	/**
 	/**
-	:name:	animateWithDelay
-	*/
-	public static func animateWithDelay(delay d: CFTimeInterval, duration: CFTimeInterval, animations: @escaping (() -> Void), completion: (() -> Void)? = nil) {
-        delay(time: d) {
-            animateWithDuration(duration: duration, animations: animations, completion: completion)
+     Executes an animation block with a given delay and duration.
+     - Parameter delay time: A CFTimeInterval.
+     - Parameter duration: An animation duration time.
+     - Parameter animations: An animation block.
+     - Parameter completion: A completion block that is executed once
+     the animations have completed.
+     */
+	public static func animate(delay time: CFTimeInterval, duration: CFTimeInterval, animations: @escaping (() -> Void), completion: (() -> Void)? = nil) {
+        delay(time: time) {
+            animate(duration: duration, animations: animations, completion: completion)
 		}
 		}
 	}
 	}
 }
 }

Sources/iOS/BasicAnimation.swift

@@ -30,159 +30,213 @@
 
 
 import UIKit
 import UIKit
 
 
-public enum AnimationKey: String {
+public enum AnimationKeyPath: String {
     case backgroundColor
     case backgroundColor
     case cornerRadius
     case cornerRadius
     case transform
     case transform
-    case transformRotation  = "transform.rotation"
-    case transformRotationX = "transform.rotation.x"
-    case transformRotationY = "transform.rotation.y"
-    case transformRotationZ = "transform.rotation.z"
-    case transformScale  = "transform.scale"
-    case transformScaleX = "transform.scale.x"
-    case transformScaleY = "transform.scale.y"
-    case transformScaleZ = "transform.scale.z"
-    case transformTranslation  = "transform.translation"
-    case transformTranslationX = "transform.translation.x"
-    case transformTranslationY = "transform.translation.y"
-    case transformTranslationZ = "transform.translation.z"
+    case rotation  = "transform.rotation"
+    case rotationX = "transform.rotation.x"
+    case rotationY = "transform.rotation.y"
+    case rotationZ = "transform.rotation.z"
+    case scale  = "transform.scale"
+    case scaleX = "transform.scale.x"
+    case scaleY = "transform.scale.y"
+    case scaleZ = "transform.scale.z"
+    case translation  = "transform.translation"
+    case translationX = "transform.translation.x"
+    case translationY = "transform.translation.y"
+    case translationZ = "transform.translation.z"
     case position
     case position
     case shadowPath
     case shadowPath
 }
 }
 
 
 extension CABasicAnimation {
 extension CABasicAnimation {
-    convenience init(keyPath key: AnimationKey) {
-        self.init(keyPath: key.rawValue)
+    /**
+     A convenience initializer that takes a given AnimationKeyPath.
+     - Parameter keyPath: An AnimationKeyPath.
+     */
+    public convenience init(keyPath: AnimationKeyPath) {
+        self.init(keyPath: keyPath.rawValue)
     }
     }
 }
 }
 
 
 extension Animation {
 extension Animation {
 	/**
 	/**
-	:name:	backgroundColor
-	*/
+     Creates a CABasicAnimation for the backgroundColor key path.
+     - Parameter color: A UIColor.
+     - Parameter duration: An animation time duration.
+     - Returns: A CABasicAnimation.
+     */
 	public static func backgroundColor(color: UIColor, duration: CFTimeInterval? = nil) -> CABasicAnimation {
 	public static func backgroundColor(color: UIColor, duration: CFTimeInterval? = nil) -> CABasicAnimation {
 		let animation = CABasicAnimation(keyPath: .backgroundColor)
 		let animation = CABasicAnimation(keyPath: .backgroundColor)
 		animation.toValue = color.cgColor
 		animation.toValue = color.cgColor
 		animation.fillMode = AnimationFillModeToValue(mode: .forwards)
 		animation.fillMode = AnimationFillModeToValue(mode: .forwards)
 		animation.isRemovedOnCompletion = false
 		animation.isRemovedOnCompletion = false
 		animation.timingFunction = AnimationTimingFunctionToValue(function: .easeInEaseOut)
 		animation.timingFunction = AnimationTimingFunctionToValue(function: .easeInEaseOut)
-		if let v = duration {
+		
+        if let v = duration {
 			animation.duration = v
 			animation.duration = v
 		}
 		}
-		return animation
+		
+        return animation
 	}
 	}
 	
 	
-	/**
-	:name:	cornerRadius
-	*/
-	public static func cornerRadius(radius: CGFloat, duration: CFTimeInterval? = nil) -> CABasicAnimation {
+    /**
+     Creates a CABasicAnimation for the cornerRadius key path.
+     - Parameter radius: A CGFloat.
+     - Parameter duration: An animation time duration.
+     - Returns: A CABasicAnimation.
+     */
+    public static func cornerRadius(radius: CGFloat, duration: CFTimeInterval? = nil) -> CABasicAnimation {
 		let animation = CABasicAnimation(keyPath: .cornerRadius)
 		let animation = CABasicAnimation(keyPath: .cornerRadius)
 		animation.toValue = radius
 		animation.toValue = radius
 		animation.fillMode = AnimationFillModeToValue(mode: .forwards)
 		animation.fillMode = AnimationFillModeToValue(mode: .forwards)
 		animation.isRemovedOnCompletion = false
 		animation.isRemovedOnCompletion = false
 		animation.timingFunction = AnimationTimingFunctionToValue(function: .easeInEaseOut)
 		animation.timingFunction = AnimationTimingFunctionToValue(function: .easeInEaseOut)
-		if let v = duration {
+		
+        if let v = duration {
 			animation.duration = v
 			animation.duration = v
 		}
 		}
-		return animation
+		
+        return animation
 	}
 	}
 	
 	
-	/**
-	:name:	translation
-	*/
-	public static func transform(transform: CATransform3D, duration: CFTimeInterval? = nil) -> CABasicAnimation {
+    /**
+     Creates a CABasicAnimation for the transform key path.
+     - Parameter transform: A CATransform3D object.
+     - Parameter duration: An animation time duration.
+     - Returns: A CABasicAnimation.
+     */
+    public static func transform(transform: CATransform3D, duration: CFTimeInterval? = nil) -> CABasicAnimation {
 		let animation = CABasicAnimation(keyPath: .transform)
 		let animation = CABasicAnimation(keyPath: .transform)
-		animation.toValue = NSValue(caTransform3D: transform)
+		
+        animation.toValue = NSValue(caTransform3D: transform)
 		animation.fillMode = AnimationFillModeToValue(mode: .forwards)
 		animation.fillMode = AnimationFillModeToValue(mode: .forwards)
 		animation.isRemovedOnCompletion = false
 		animation.isRemovedOnCompletion = false
 		animation.timingFunction = AnimationTimingFunctionToValue(function: .easeInEaseOut)
 		animation.timingFunction = AnimationTimingFunctionToValue(function: .easeInEaseOut)
-		if let v = duration {
+		
+        if let v = duration {
 			animation.duration = v
 			animation.duration = v
 		}
 		}
-		return animation
+		
+        return animation
 	}
 	}
 	
 	
-	/**
-	:name:	rotate
-	*/
-	public static func rotate(angle: CGFloat? = nil, rotation: CGFloat? = nil, duration: CFTimeInterval? = nil) -> CABasicAnimation {
-		let animation = CABasicAnimation(keyPath: .transformRotation)
-		if let v: CGFloat = angle {
+    /**
+     Creates a CABasicAnimation for the transform.rotation key path.
+     - Parameter angle: An optional CGFloat.
+     - Parameter rotation: An optional CGFloat.
+     - Parameter duration: An animation time duration.
+     - Returns: A CABasicAnimation.
+     */
+    public static func rotate(angle: CGFloat? = nil, rotation: CGFloat? = nil, duration: CFTimeInterval? = nil) -> CABasicAnimation {
+		let animation = CABasicAnimation(keyPath: .rotation)
+        
+        if let v = angle {
 			animation.toValue = (CGFloat(M_PI) * v / 180) as NSNumber
 			animation.toValue = (CGFloat(M_PI) * v / 180) as NSNumber
-		} else if let v: CGFloat = rotation {
+		} else if let v = rotation {
 			animation.toValue = (CGFloat(M_PI * 2) * v) as NSNumber
 			animation.toValue = (CGFloat(M_PI * 2) * v) as NSNumber
 		}
 		}
-		animation.fillMode = AnimationFillModeToValue(mode: .forwards)
+		
+        animation.fillMode = AnimationFillModeToValue(mode: .forwards)
 		animation.isRemovedOnCompletion = false
 		animation.isRemovedOnCompletion = false
 		animation.timingFunction = AnimationTimingFunctionToValue(function: .easeInEaseOut)
 		animation.timingFunction = AnimationTimingFunctionToValue(function: .easeInEaseOut)
-		if let v = duration {
+		
+        if let v = duration {
 			animation.duration = v
 			animation.duration = v
 		}
 		}
 		return animation
 		return animation
 	}
 	}
 	
 	
-	/**
-	:name:	rotateX
-	*/
-	public static func rotateX(angle: CGFloat? = nil, rotation: CGFloat? = nil, duration: CFTimeInterval? = nil) -> CABasicAnimation {
-		let animation = CABasicAnimation(keyPath: .transformRotationX)
-		if let v: CGFloat = angle {
+    /**
+     Creates a CABasicAnimation for the transform.rotation.x key path.
+     - Parameter angle: An optional CGFloat.
+     - Parameter rotation: An optional CGFloat.
+     - Parameter duration: An animation time duration.
+     - Returns: A CABasicAnimation.
+     */
+    public static func rotateX(angle: CGFloat? = nil, rotation: CGFloat? = nil, duration: CFTimeInterval? = nil) -> CABasicAnimation {
+		let animation = CABasicAnimation(keyPath: .rotationX)
+		
+        if let v: CGFloat = angle {
 			animation.toValue = (CGFloat(M_PI) * v / 180) as NSNumber
 			animation.toValue = (CGFloat(M_PI) * v / 180) as NSNumber
 		} else if let v: CGFloat = rotation {
 		} else if let v: CGFloat = rotation {
 			animation.toValue = (CGFloat(M_PI * 2) * v) as NSNumber
 			animation.toValue = (CGFloat(M_PI * 2) * v) as NSNumber
 		}
 		}
-		animation.fillMode = AnimationFillModeToValue(mode: .forwards)
+		
+        animation.fillMode = AnimationFillModeToValue(mode: .forwards)
 		animation.isRemovedOnCompletion = false
 		animation.isRemovedOnCompletion = false
 		animation.timingFunction = AnimationTimingFunctionToValue(function: .easeInEaseOut)
 		animation.timingFunction = AnimationTimingFunctionToValue(function: .easeInEaseOut)
-		if let v = duration {
+		
+        if let v = duration {
 			animation.duration = v
 			animation.duration = v
 		}
 		}
-		return animation
+		
+        return animation
 	}
 	}
 	
 	
-	/**
-	:name:	rotateY
-	*/
-	public static func rotateY(angle: CGFloat? = nil, rotation: CGFloat? = nil, duration: CFTimeInterval? = nil) -> CABasicAnimation {
-		let animation = CABasicAnimation(keyPath: .transformRotationY)
-		if let v: CGFloat = angle {
+    /**
+     Creates a CABasicAnimation for the transform.rotation.y key path.
+     - Parameter angle: An optional CGFloat.
+     - Parameter rotation: An optional CGFloat.
+     - Parameter duration: An animation time duration.
+     - Returns: A CABasicAnimation.
+     */
+    public static func rotateY(angle: CGFloat? = nil, rotation: CGFloat? = nil, duration: CFTimeInterval? = nil) -> CABasicAnimation {
+		let animation = CABasicAnimation(keyPath: .rotationY)
+		
+        if let v: CGFloat = angle {
 			animation.toValue = (CGFloat(M_PI) * v / 180) as NSNumber
 			animation.toValue = (CGFloat(M_PI) * v / 180) as NSNumber
 		} else if let v: CGFloat = rotation {
 		} else if let v: CGFloat = rotation {
 			animation.toValue = (CGFloat(M_PI * 2) * v) as NSNumber
 			animation.toValue = (CGFloat(M_PI * 2) * v) as NSNumber
 		}
 		}
-		animation.fillMode = AnimationFillModeToValue(mode: .forwards)
+		
+        animation.fillMode = AnimationFillModeToValue(mode: .forwards)
 		animation.isRemovedOnCompletion = false
 		animation.isRemovedOnCompletion = false
 		animation.timingFunction = AnimationTimingFunctionToValue(function: .easeInEaseOut)
 		animation.timingFunction = AnimationTimingFunctionToValue(function: .easeInEaseOut)
-		if let v = duration {
+		
+        if let v = duration {
 			animation.duration = v
 			animation.duration = v
 		}
 		}
-		return animation
+		
+        return animation
 	}
 	}
 	
 	
-	/**
-	:name:	rotateZ
-	*/
-	public static func rotateZ(angle: CGFloat? = nil, rotation: CGFloat? = nil, duration: CFTimeInterval? = nil) -> CABasicAnimation {
-		let animation = CABasicAnimation(keyPath: .transformRotationZ)
-		if let v: CGFloat = angle {
+    /**
+     Creates a CABasicAnimation for the transform.rotation.z key path.
+     - Parameter angle: An optional CGFloat.
+     - Parameter rotation: An optional CGFloat.
+     - Parameter duration: An animation time duration.
+     - Returns: A CABasicAnimation.
+     */
+    public static func rotateZ(angle: CGFloat? = nil, rotation: CGFloat? = nil, duration: CFTimeInterval? = nil) -> CABasicAnimation {
+		let animation = CABasicAnimation(keyPath: .rotationZ)
+		
+        if let v: CGFloat = angle {
 			animation.toValue = (CGFloat(M_PI) * v / 180) as NSNumber
 			animation.toValue = (CGFloat(M_PI) * v / 180) as NSNumber
 		} else if let v: CGFloat = rotation {
 		} else if let v: CGFloat = rotation {
 			animation.toValue = (CGFloat(M_PI * 2) * v) as NSNumber
 			animation.toValue = (CGFloat(M_PI * 2) * v) as NSNumber
 		}
 		}
-		animation.fillMode = AnimationFillModeToValue(mode: .forwards)
+		
+        animation.fillMode = AnimationFillModeToValue(mode: .forwards)
 		animation.isRemovedOnCompletion = false
 		animation.isRemovedOnCompletion = false
 		animation.timingFunction = AnimationTimingFunctionToValue(function: .easeInEaseOut)
 		animation.timingFunction = AnimationTimingFunctionToValue(function: .easeInEaseOut)
-		if let v = duration {
+		
+        if let v = duration {
 			animation.duration = v
 			animation.duration = v
 		}
 		}
-		return animation
+		
+        return animation
 	}
 	}
 
 
-	/**
-	:name:	scale
-	*/
-	public static func scale(scale: CGFloat, duration: CFTimeInterval? = nil) -> CABasicAnimation {
-		let animation = CABasicAnimation(keyPath: .transformScale)
+    /**
+     Creates a CABasicAnimation for the transform.scale key path.
+     - Parameter by scale: A CGFloat.
+     - Parameter duration: An animation time duration.
+     - Returns: A CABasicAnimation.
+     */
+    public static func scale(by scale: CGFloat, duration: CFTimeInterval? = nil) -> CABasicAnimation {
+		let animation = CABasicAnimation(keyPath: .scale)
 		animation.toValue = scale as NSNumber
 		animation.toValue = scale as NSNumber
 		animation.fillMode = AnimationFillModeToValue(mode: .forwards)
 		animation.fillMode = AnimationFillModeToValue(mode: .forwards)
 		animation.isRemovedOnCompletion = false
 		animation.isRemovedOnCompletion = false
@@ -193,11 +247,14 @@ extension Animation {
 		return animation
 		return animation
 	}
 	}
 	
 	
-	/**
-	:name:	scaleX
-	*/
-	public static func scaleX(scale: CGFloat, duration: CFTimeInterval? = nil) -> CABasicAnimation {
-		let animation = CABasicAnimation(keyPath: .transformScaleX)
+    /**
+     Creates a CABasicAnimation for the transform.scale.x key path.
+     - Parameter by scale: A CGFloat.
+     - Parameter duration: An animation time duration.
+     - Returns: A CABasicAnimation.
+     */
+    public static func scaleX(by scale: CGFloat, duration: CFTimeInterval? = nil) -> CABasicAnimation {
+		let animation = CABasicAnimation(keyPath: .scaleX)
 		animation.toValue = scale as NSNumber
 		animation.toValue = scale as NSNumber
 		animation.fillMode = AnimationFillModeToValue(mode: .forwards)
 		animation.fillMode = AnimationFillModeToValue(mode: .forwards)
 		animation.isRemovedOnCompletion = false
 		animation.isRemovedOnCompletion = false
@@ -208,11 +265,14 @@ extension Animation {
 		return animation
 		return animation
 	}
 	}
 	
 	
-	/**
-	:name:	scaleY
-	*/
-	public static func scaleY(scale: CGFloat, duration: CFTimeInterval? = nil) -> CABasicAnimation {
-		let animation = CABasicAnimation(keyPath: .transformScaleY)
+    /**
+     Creates a CABasicAnimation for the transform.scale.y key path.
+     - Parameter by scale: A CGFloat.
+     - Parameter duration: An animation time duration.
+     - Returns: A CABasicAnimation.
+     */
+    public static func scaleY(by scale: CGFloat, duration: CFTimeInterval? = nil) -> CABasicAnimation {
+		let animation = CABasicAnimation(keyPath: .scaleY)
 		animation.toValue = scale as NSNumber
 		animation.toValue = scale as NSNumber
 		animation.fillMode = AnimationFillModeToValue(mode: .forwards)
 		animation.fillMode = AnimationFillModeToValue(mode: .forwards)
 		animation.isRemovedOnCompletion = false
 		animation.isRemovedOnCompletion = false
@@ -223,11 +283,14 @@ extension Animation {
 		return animation
 		return animation
 	}
 	}
 	
 	
-	/**
-	:name:	scaleZ
-	*/
-	public static func scaleZ(scale: CGFloat, duration: CFTimeInterval? = nil) -> CABasicAnimation {
-		let animation = CABasicAnimation(keyPath: .transformScaleZ)
+    /**
+     Creates a CABasicAnimation for the transform.scale.z key path.
+     - Parameter by scale: A CGFloat.
+     - Parameter duration: An animation time duration.
+     - Returns: A CABasicAnimation.
+     */
+    public static func scaleZ(by scale: CGFloat, duration: CFTimeInterval? = nil) -> CABasicAnimation {
+		let animation = CABasicAnimation(keyPath: .scaleZ)
 		animation.toValue = scale as NSNumber
 		animation.toValue = scale as NSNumber
 		animation.fillMode = AnimationFillModeToValue(mode: .forwards)
 		animation.fillMode = AnimationFillModeToValue(mode: .forwards)
 		animation.isRemovedOnCompletion = false
 		animation.isRemovedOnCompletion = false
@@ -238,90 +301,123 @@ extension Animation {
 		return animation
 		return animation
 	}
 	}
 	
 	
-	/**
-	:name:	translate
-	*/
-	public static func translate(translation: CGSize, duration: CFTimeInterval? = nil) -> CABasicAnimation {
-		let animation = CABasicAnimation(keyPath: .transformTranslation)
-		animation.toValue = NSValue(cgSize: translation)
+    /**
+     Creates a CABasicAnimation for the transform.translation key path.
+     - Parameter size: A CGSize.
+     - Parameter duration: An animation time duration.
+     - Returns: A CABasicAnimation.
+     */
+    public static func translation(size: CGSize, duration: CFTimeInterval? = nil) -> CABasicAnimation {
+		let animation = CABasicAnimation(keyPath: .translation)
+		animation.toValue = NSValue(cgSize: size)
 		animation.fillMode = AnimationFillModeToValue(mode: .forwards)
 		animation.fillMode = AnimationFillModeToValue(mode: .forwards)
 		animation.isRemovedOnCompletion = false
 		animation.isRemovedOnCompletion = false
 		animation.timingFunction = AnimationTimingFunctionToValue(function: .easeInEaseOut)
 		animation.timingFunction = AnimationTimingFunctionToValue(function: .easeInEaseOut)
-		if let v = duration {
+		
+        if let v = duration {
 			animation.duration = v
 			animation.duration = v
 		}
 		}
-		return animation
+		
+        return animation
 	}
 	}
 	
 	
-	/**
-	:name:	translateX
-	*/
-	public static func translateX(translation: CGFloat, duration: CFTimeInterval? = nil) -> CABasicAnimation {
-		let animation = CABasicAnimation(keyPath: .transformTranslationX)
+    /**
+     Creates a CABasicAnimation for the transform.translation.x key path.
+     - Parameter by translation: A CGFloat.
+     - Parameter duration: An animation time duration.
+     - Returns: A CABasicAnimation.
+     */
+    public static func translationX(by translation: CGFloat, duration: CFTimeInterval? = nil) -> CABasicAnimation {
+		let animation = CABasicAnimation(keyPath: .translationX)
 		animation.toValue = translation as NSNumber
 		animation.toValue = translation as NSNumber
 		animation.fillMode = AnimationFillModeToValue(mode: .forwards)
 		animation.fillMode = AnimationFillModeToValue(mode: .forwards)
 		animation.isRemovedOnCompletion = false
 		animation.isRemovedOnCompletion = false
 		animation.timingFunction = AnimationTimingFunctionToValue(function: .easeInEaseOut)
 		animation.timingFunction = AnimationTimingFunctionToValue(function: .easeInEaseOut)
-		if let v = duration {
+		
+        if let v = duration {
 			animation.duration = v
 			animation.duration = v
 		}
 		}
-		return animation
+		
+        return animation
 	}
 	}
 	
 	
-	/**
-	:name:	translateY
-	*/
-	public static func translateY(translation: CGFloat, duration: CFTimeInterval? = nil) -> CABasicAnimation {
-		let animation = CABasicAnimation(keyPath: .transformTranslationY)
+    /**
+     Creates a CABasicAnimation for the transform.translation.y key path.
+     - Parameter by translation: A CGFloat.
+     - Parameter duration: An animation time duration.
+     - Returns: A CABasicAnimation.
+     */
+    public static func translationY(by translation: CGFloat, duration: CFTimeInterval? = nil) -> CABasicAnimation {
+		let animation = CABasicAnimation(keyPath: .translationY)
 		animation.toValue = translation as NSNumber
 		animation.toValue = translation as NSNumber
         animation.fillMode = AnimationFillModeToValue(mode: .forwards)
         animation.fillMode = AnimationFillModeToValue(mode: .forwards)
         animation.isRemovedOnCompletion = false
         animation.isRemovedOnCompletion = false
         animation.timingFunction = AnimationTimingFunctionToValue(function: .easeInEaseOut)
         animation.timingFunction = AnimationTimingFunctionToValue(function: .easeInEaseOut)
-		if let v = duration {
+		
+        if let v = duration {
 			animation.duration = v
 			animation.duration = v
 		}
 		}
-		return animation
+		
+        return animation
 	}
 	}
 	
 	
-	/**
-	:name:	translateZ
-	*/
-	public static func translateZ(translation: CGFloat, duration: CFTimeInterval? = nil) -> CABasicAnimation {
-		let animation = CABasicAnimation(keyPath: .transformTranslationZ)
+    /**
+     Creates a CABasicAnimation for the transform.translation.z key path.
+     - Parameter by translation: A CGFloat.
+     - Parameter duration: An animation time duration.
+     - Returns: A CABasicAnimation.
+     */
+    public static func translationZ(by translation: CGFloat, duration: CFTimeInterval? = nil) -> CABasicAnimation {
+		let animation = CABasicAnimation(keyPath: .translationZ)
 		animation.toValue = translation as NSNumber
 		animation.toValue = translation as NSNumber
         animation.fillMode = AnimationFillModeToValue(mode: .forwards)
         animation.fillMode = AnimationFillModeToValue(mode: .forwards)
         animation.isRemovedOnCompletion = false
         animation.isRemovedOnCompletion = false
         animation.timingFunction = AnimationTimingFunctionToValue(function: .easeInEaseOut)
         animation.timingFunction = AnimationTimingFunctionToValue(function: .easeInEaseOut)
-		if let v = duration {
+		
+        if let v = duration {
 			animation.duration = v
 			animation.duration = v
 		}
 		}
-		return animation
+		
+        return animation
 	}
 	}
 	
 	
-	/**
-	:name:	position
-	*/
-	public static func position(point: CGPoint, duration: CFTimeInterval? = nil) -> CABasicAnimation {
+    /**
+     Creates a CABasicAnimation for the position key path.
+     - Parameter to point: A CGPoint.
+     - Parameter duration: An animation time duration.
+     - Returns: A CABasicAnimation.
+     */
+    public static func position(to point: CGPoint, duration: CFTimeInterval? = nil) -> CABasicAnimation {
 		let animation = CABasicAnimation(keyPath: .position)
 		let animation = CABasicAnimation(keyPath: .position)
 		animation.toValue = NSValue(cgPoint: point)
 		animation.toValue = NSValue(cgPoint: point)
         animation.fillMode = AnimationFillModeToValue(mode: .forwards)
         animation.fillMode = AnimationFillModeToValue(mode: .forwards)
         animation.isRemovedOnCompletion = false
         animation.isRemovedOnCompletion = false
         animation.timingFunction = AnimationTimingFunctionToValue(function: .easeInEaseOut)
         animation.timingFunction = AnimationTimingFunctionToValue(function: .easeInEaseOut)
-		if let v = duration {
+		
+        if let v = duration {
 			animation.duration = v
 			animation.duration = v
 		}
 		}
-		return animation
+		
+        return animation
 	}
 	}
 	
 	
-	public static func shadowPath(path: CGPath, duration: CFTimeInterval? = nil) -> CABasicAnimation {
+    /**
+     Creates a CABasicAnimation for the shadowPath key path.
+     - Parameter to path: A CGPath.
+     - Parameter duration: An animation time duration.
+     - Returns: A CABasicAnimation.
+     */
+    public static func shadowPath(to path: CGPath, duration: CFTimeInterval? = nil) -> CABasicAnimation {
 		let animation = CABasicAnimation(keyPath: .shadowPath)
 		let animation = CABasicAnimation(keyPath: .shadowPath)
 		animation.toValue = path
 		animation.toValue = path
         animation.fillMode = AnimationFillModeToValue(mode: .forwards)
         animation.fillMode = AnimationFillModeToValue(mode: .forwards)
         animation.isRemovedOnCompletion = false
         animation.isRemovedOnCompletion = false
-        animation.timingFunction = AnimationTimingFunctionToValue(function: .liner)
-		if let v = duration {
+        animation.timingFunction = AnimationTimingFunctionToValue(function: .linear)
+		
+        if let v = duration {
 			animation.duration = v
 			animation.duration = v
 		}
 		}
-		return animation
+		
+        return animation
 	}
 	}
 }
 }

Sources/iOS/Capture/Capture.swift

@@ -629,7 +629,7 @@ open class Capture: View, UIGestureRecognizerDelegate {
 	
 	
 	/// Animates the tap and layer.
 	/// Animates the tap and layer.
 	private func animateTap(view: UIView, point: CGPoint) {
 	private func animateTap(view: UIView, point: CGPoint) {
-//		Animation.animationDisabled { [weak layer] in
+//		Animation.disable { [weak layer] in
 //            guard let v = layer else {
 //            guard let v = layer else {
 //                return
 //                return
 //            }
 //            }
@@ -644,7 +644,7 @@ open class Capture: View, UIGestureRecognizerDelegate {
 //			v.transform = CATransform3DMakeScale(0.5, 0.5, 1)
 //			v.transform = CATransform3DMakeScale(0.5, 0.5, 1)
 //		}) {
 //		}) {
 //			Animation.delay(time: 0.4) { [weak layer] in
 //			Animation.delay(time: 0.4) { [weak layer] in
-//                Animation.animationDisabled { [weak layer] in
+//                Animation.disable { [weak layer] in
 //                    guard let v = layer else {
 //                    guard let v = layer else {
 //                        return
 //                        return
 //                    }
 //                    }

Sources/iOS/KeyframeAnimation.swift

@@ -32,19 +32,21 @@ import UIKit
 
 
 @objc(AnimationRotationMode)
 @objc(AnimationRotationMode)
 public enum AnimationRotationMode: Int {
 public enum AnimationRotationMode: Int {
-	case none
+	case `default`
 	case auto
 	case auto
 	case autoReverse
 	case autoReverse
 }
 }
 
 
 /**
 /**
-	:name:	AnimationRotationModeToValue
-*/
+ Converts an AnimationRotationMode to a corresponding CAAnimationRotate key.
+ - Parameter mode: An AnimationRotationMode.
+ - Returns: An optional CAAnimationRotate key String.
+ */
 public func AnimationRotationModeToValue(mode: AnimationRotationMode) -> String? {
 public func AnimationRotationModeToValue(mode: AnimationRotationMode) -> String? {
 	switch mode {
 	switch mode {
-	case .none:
-		return nil
-	case .auto:
+    case .default:
+        return nil
+    case .auto:
 		return kCAAnimationRotateAuto
 		return kCAAnimationRotateAuto
 	case .autoReverse:
 	case .autoReverse:
 		return kCAAnimationRotateAutoReverse
 		return kCAAnimationRotateAutoReverse
@@ -53,11 +55,15 @@ public func AnimationRotationModeToValue(mode: AnimationRotationMode) -> String?
 
 
 extension Animation {
 extension Animation {
 	/**
 	/**
-	:name: path
-	*/
+     Creates a CAKeyframeAnimation.
+     - Parameter bezierPath: A UIBezierPath.
+     - Parameter mode: An AnimationRotationMode.
+     - Parameter duration: An animation duration time.
+     - Returns: A CAKeyframeAnimation.
+     */
 	public static func path(bezierPath: UIBezierPath, mode: AnimationRotationMode = .auto, duration: CFTimeInterval? = nil) -> CAKeyframeAnimation {
 	public static func path(bezierPath: UIBezierPath, mode: AnimationRotationMode = .auto, duration: CFTimeInterval? = nil) -> CAKeyframeAnimation {
-		let animation: CAKeyframeAnimation = CAKeyframeAnimation()
-		animation.keyPath = AnimationKey.position.rawValue
+		let animation = CAKeyframeAnimation()
+		animation.keyPath = AnimationKeyPath.position.rawValue
 		animation.path = bezierPath.cgPath
 		animation.path = bezierPath.cgPath
         animation.rotationMode = AnimationRotationModeToValue(mode: mode)
         animation.rotationMode = AnimationRotationModeToValue(mode: mode)
 		if let v = duration {
 		if let v = duration {

Sources/iOS/Material+CALayer.swift

@@ -321,7 +321,7 @@ extension CALayer {
         } else if nil == shadowPath {
         } else if nil == shadowPath {
             shadowPath = UIBezierPath(roundedRect: bounds, cornerRadius: cornerRadius).cgPath
             shadowPath = UIBezierPath(roundedRect: bounds, cornerRadius: cornerRadius).cgPath
         } else {
         } else {
-            let a = Animation.shadowPath(path: UIBezierPath(roundedRect: bounds, cornerRadius: cornerRadius).cgPath)
+            let a = Animation.shadowPath(to: UIBezierPath(roundedRect: bounds, cornerRadius: cornerRadius).cgPath)
             a.fromValue = shadowPath
             a.fromValue = shadowPath
             animate(animation: a)
             animate(animation: a)
         }
         }

Sources/iOS/PulseAnimation.swift

@@ -71,7 +71,7 @@ internal extension Animation {
         
         
         visualLayer.masksToBounds = !(.centerRadialBeyondBounds == pulse.animation || .radialBeyondBounds == pulse.animation)
         visualLayer.masksToBounds = !(.centerRadialBeyondBounds == pulse.animation || .radialBeyondBounds == pulse.animation)
         
         
-        Animation.animationDisabled(animations: { [visualLayer = visualLayer, pulse = pulse] in
+        Animation.disable(animations: { [visualLayer = visualLayer, pulse = pulse] in
             bLayer.frame = visualLayer.bounds
             bLayer.frame = visualLayer.bounds
             pLayer.bounds = CGRect(x: 0, y: 0, width: n, height: n)
             pLayer.bounds = CGRect(x: 0, y: 0, width: n, height: n)
             
             
@@ -99,7 +99,7 @@ internal extension Animation {
         
         
         switch pulse.animation {
         switch pulse.animation {
         case .center, .centerWithBacking, .centerRadialBeyondBounds, .radialBeyondBounds, .point, .pointWithBacking:
         case .center, .centerWithBacking, .centerRadialBeyondBounds, .radialBeyondBounds, .point, .pointWithBacking:
-            pLayer.add(Animation.scale(scale: 1, duration: duration), forKey: nil)
+            pLayer.add(Animation.scale(by: 1, duration: duration), forKey: nil)
         default:break
         default:break
         }
         }
         
         
@@ -138,8 +138,8 @@ internal extension Animation {
             
             
             switch pulse.animation {
             switch pulse.animation {
             case .center, .centerWithBacking, .centerRadialBeyondBounds, .radialBeyondBounds, .point, .pointWithBacking:
             case .center, .centerWithBacking, .centerRadialBeyondBounds, .radialBeyondBounds, .point, .pointWithBacking:
-                pLayer.add(Animation.animationGroup(animations: [
-                    Animation.scale(scale: .center == pulse.animation ? 1 : 1.325),
+                pLayer.add(Animation.animate(group: [
+                    Animation.scale(by: .center == pulse.animation ? 1 : 1.325),
                     Animation.backgroundColor(color: pulse.color.withAlphaComponent(0))
                     Animation.backgroundColor(color: pulse.color.withAlphaComponent(0))
                 ], duration: duration), forKey: nil)
                 ], duration: duration), forKey: nil)
             default:break
             default:break

Sources/iOS/TransitionAnimation.swift

@@ -30,70 +30,78 @@
 
 
 import UIKit
 import UIKit
 
 
-public typealias AnimationTransitionType = String
-public typealias AnimationTransitionSubTypeType = String
-
 @objc(AnimationTransition)
 @objc(AnimationTransition)
 public enum AnimationTransition: Int {
 public enum AnimationTransition: Int {
-	case Fade
-	case MoveIn
-	case Push
-	case Reveal
+	case fade
+	case moveIn
+	case push
+	case reveal
 }
 }
 
 
-@objc(AnimationTransitionSubType)
-public enum AnimationTransitionSubType: Int {
-	case Right
-	case Left
-	case Top
-	case Bottom
+@objc(AnimationTransitionDirection)
+public enum AnimationTransitionDirection: Int {
+	case `default`
+    case right
+	case left
+	case top
+	case bottom
 }
 }
 
 
 /**
 /**
-	:name:	AnimationTransitionToValue
-*/
-public func AnimationTransitionToValue(transition: AnimationTransition) -> AnimationTransitionType {
-	switch transition {
-	case .Fade:
+ Converts an AnimationTransition to a corresponding CATransition key.
+ - Parameter transition: An AnimationTransition.
+ - Returns: A CATransition key String.
+ */
+public func AnimationTransitionToValue(transition type: AnimationTransition) -> String {
+	switch type {
+	case .fade:
 		return kCATransitionFade
 		return kCATransitionFade
-	case .MoveIn:
+	case .moveIn:
 		return kCATransitionMoveIn
 		return kCATransitionMoveIn
-	case .Push:
+	case .push:
 		return kCATransitionPush
 		return kCATransitionPush
-	case .Reveal:
+	case .reveal:
 		return kCATransitionReveal
 		return kCATransitionReveal
 	}
 	}
 }
 }
 
 
 /**
 /**
-	:name:	AnimationTransitionSubTypeToValue
-*/
-public func AnimationTransitionSubTypeToValue(direction: AnimationTransitionSubType) -> AnimationTransitionSubTypeType {
+ Converts an AnimationTransitionDirection to a corresponding CATransition direction key.
+ - Parameter direction: An AnimationTransitionDirection.
+ - Returns: An optional CATransition direction key String.
+ */
+public func AnimationTransitionDirectionToValue(direction: AnimationTransitionDirection) -> String? {
 	switch direction {
 	switch direction {
-	case .Right:
+    case .default:
+        return nil
+    case .right:
 		return kCATransitionFromRight
 		return kCATransitionFromRight
-	case .Left:
+	case .left:
 		return kCATransitionFromLeft
 		return kCATransitionFromLeft
-	case .Top:
+	case .top:
 		return kCATransitionFromBottom
 		return kCATransitionFromBottom
-	case .Bottom:
+	case .bottom:
 		return kCATransitionFromTop
 		return kCATransitionFromTop
 	}
 	}
 }
 }
 
 
 extension Animation {
 extension Animation {
 	/**
 	/**
-	:name: transition
-	*/
-	public static func transition(type: AnimationTransition, direction: AnimationTransitionSubType? = nil, duration: CFTimeInterval? = nil) -> CATransition {
-		let animation: CATransition = CATransition()
+     Creates a CATransition animation.
+     - Parameter type: An AnimationTransition.
+     - Parameter direction: An optional AnimationTransitionDirection.
+     - Parameter duration: An optional duration time.
+     - Returns: A CATransition.
+     */
+	public static func transition(type: AnimationTransition, direction: AnimationTransitionDirection = .default, duration: CFTimeInterval? = nil) -> CATransition {
+		let animation = CATransition()
 		animation.type = AnimationTransitionToValue(transition: type)
 		animation.type = AnimationTransitionToValue(transition: type)
-		if let d = direction {
-			animation.subtype = AnimationTransitionSubTypeToValue(direction: d)
-		}
-		if let v: CFTimeInterval = duration {
+        animation.subtype = AnimationTransitionDirectionToValue(direction: direction)
+		
+        if let v = duration {
 			animation.duration = v
 			animation.duration = v
 		}
 		}
-		return animation
+		
+        return animation
 	}
 	}
 }
 }