migrated code base to swift 2.0 syntax

Author: apouche

ManualLayout.xcodeproj/project.pbxproj

@@ -309,6 +309,7 @@
 		5FB4CBE01A9BBE7500C2FB4F /* Project object */ = {
 			isa = PBXProject;
 			attributes = {
+				LastSwiftUpdateCheck = 0700;
 				LastUpgradeCheck = 0610;
 				ORGANIZATIONNAME = "Baris Sencan";
 				TargetAttributes = {

ManualLayout/HelperFunctions.swift

@@ -16,49 +16,49 @@ internal func snapToPixel(pointCoordinate coordinate: CGFloat) -> CGFloat {
 //MARK: - Insetting
 
 public func inset(view: UIView, amount: CGFloat) -> CGRect {
-  return inset(view.frame, amount)
+  return inset(view.frame, amount: amount)
 }
 
 public func inset(layer: CALayer, amount: CGFloat) -> CGRect {
-  return inset(layer.frame, amount)
+  return inset(layer.frame, amount: amount)
 }
 
 public func inset(rect: CGRect, amount: CGFloat) -> CGRect {
   return CGRectInset(rect, amount, amount)
 }
 
 public func inset(view: UIView, dx: CGFloat, dy: CGFloat) -> CGRect {
-  return inset(view.frame, dx, dy)
+  return inset(view.frame, dx: dx, dy: dy)
 }
 
 public func inset(layer: CALayer, dx: CGFloat, dy: CGFloat) -> CGRect {
-  return inset(layer.frame, dx, dy)
+  return inset(layer.frame, dx: dx, dy: dy)
 }
 
 public func inset(rect: CGRect, dx: CGFloat, dy: CGFloat) -> CGRect {
   return CGRectInset(rect, dx, dy)
 }
 
 public func inset(view: UIView, top: CGFloat, left: CGFloat, bottom: CGFloat, right: CGFloat) -> CGRect {
-  return inset(view.frame, top, left, bottom, right)
+  return inset(view.frame, top: top, left: left, bottom: bottom, right: right)
 }
 
 public func inset(layer: CALayer, top: CGFloat, left: CGFloat, bottom: CGFloat, right: CGFloat) -> CGRect {
-  return inset(layer.frame, top, left, bottom, right)
+  return inset(layer.frame, top: top, left: left, bottom: bottom, right: right)
 }
 
 public func inset(rect: CGRect, top: CGFloat, left: CGFloat, bottom: CGFloat, right: CGFloat) -> CGRect {
   return CGRect(
-    origin: offset(rect.origin, left, top),
-    size: inset(rect.size, top, left, bottom, right))
+    origin: offset(rect.origin, dx: left, dy: top),
+    size: inset(rect.size, top: top, left: left, bottom: bottom, right: right))
 }
 
 public func inset(size: CGSize, amount: CGFloat) -> CGSize {
-  return inset(size, amount, amount)
+  return inset(size, dx: amount, dy: amount)
 }
 
 public func inset(size: CGSize, dx: CGFloat, dy: CGFloat) -> CGSize {
-  return inset(size, dy, dx, dy, dx)
+  return inset(size, top: dy, left: dx, bottom: dy, right: dx)
 }
 
 public func inset(size: CGSize, top: CGFloat, left: CGFloat, bottom: CGFloat, right: CGFloat) -> CGSize {
@@ -70,31 +70,31 @@ public func inset(size: CGSize, top: CGFloat, left: CGFloat, bottom: CGFloat, ri
 // MARK: - Offsetting
 
 public func offset(view: UIView, amount: CGFloat) -> CGRect {
-  return offset(view.frame, amount)
+  return offset(view.frame, amount: amount)
 }
 
 public func offset(layer: CALayer, amount: CGFloat) -> CGRect {
-  return offset(layer.frame, amount)
+  return offset(layer.frame, amount: amount)
 }
 
 public func offset(rect: CGRect, amount: CGFloat) -> CGRect {
   return CGRectOffset(rect, amount, amount)
 }
 
 public func offset(view: UIView, dx: CGFloat, dy: CGFloat) -> CGRect {
-  return offset(view.frame, dx, dy)
+  return offset(view.frame, dx: dx, dy: dy)
 }
 
 public func offset(layer: CALayer, dx: CGFloat, dy: CGFloat) -> CGRect {
-  return offset(layer.frame, dx, dy)
+  return offset(layer.frame, dx: dx, dy: dy)
 }
 
 public func offset(rect: CGRect, dx: CGFloat, dy: CGFloat) -> CGRect {
   return CGRectOffset(rect, dx, dy)
 }
 
 public func offset(point: CGPoint, amount: CGFloat) -> CGPoint {
-  return offset(point, amount, amount)
+  return offset(point, dx: amount, dy: amount)
 }
 
 public func offset(point: CGPoint, dx: CGFloat, dy: CGFloat) -> CGPoint {

ManualLayoutTests/HelperFunctionTests.swift

@@ -19,79 +19,79 @@ class HelperFunctionTests: XCTestCase {
   }
 
   func testInsetRectSingleArg() {
-    view.frame = inset(view, 1)
+    view.frame = inset(view, amount: 1)
     XCTAssertEqual(
       view.frame,
       CGRect(x: 2, y: 4, width: 4, height: 6),
       "insetting with amount should inset correctly")
   }
 
   func testInsetRectTwoArg() {
-    view.frame = inset(view, 1, 2)
+    view.frame = inset(view, dx: 1, dy: 2)
     XCTAssertEqual(
       view.frame,
       CGRect(x: 2, y: 5, width: 4, height: 4),
       "insetting with dx and dy should inset correctly")
   }
 
   func testInsetRectFourArg() {
-    view.frame = inset(view, 1, 2, 3, 4)
+    view.frame = inset(view, top: 1, left: 2, bottom: 3, right: 4)
     XCTAssertEqual(
       view.frame,
       CGRect(x: 3, y: 4, width: 0, height: 4),
       "insetting with four arguments should inset correctly")
   }
 
   func testInsetSizeSingleArg() {
-    let size = inset(view.frame.size, 1)
+    let size = inset(view.frame.size, amount: 1)
     XCTAssertEqual(
       size,
       CGSize(width: 4, height: 6),
       "insetting size with amount should inset correctly")
   }
 
   func testInsetSizeTwoArg() {
-    let size = inset(view.frame.size, 1, 2)
+    let size = inset(view.frame.size, dx: 1, dy: 2)
     XCTAssertEqual(
       size,
       CGSize(width: 4, height: 4),
       "insetting size with two arguments should inset correctly")
   }
 
   func testInsetSizeFourArg() {
-    let size = inset(view.frame.size, 1, 2, 3, 4)
+    let size = inset(view.frame.size, top: 1, left: 2, bottom: 3, right: 4)
     XCTAssertEqual(
       size,
       CGSize(width: 0, height: 4),
       "insetting size with four arguments should inset correctly")
   }
 
   func testOffsetSingleArg() {
-    view.frame = offset(view, 1)
+    view.frame = offset(view, amount: 1)
     XCTAssertEqual(
       view.frame,
       CGRect(x: 2, y: 4, width: 6, height: 8),
       "offsetting with amount should offset correctly")
   }
 
   func testOffsetTwoArg() {
-    view.frame = offset(view, 1, 2)
+    view.frame = offset(view, dx: 1, dy: 2)
     XCTAssertEqual(
       view.frame,
       CGRect(x: 2, y: 5, width: 6, height: 8),
       "offsetting with dx and dy should offset correctly")
   }
 
   func testOffsetPointSingleArg() {
-    let origin = offset(view.frame.origin, 1)
+    let origin = offset(view.frame.origin, amount: 1)
     XCTAssertEqual(
       origin,
       CGPoint(x: 2, y: 4),
       "offsetting origin with amount should offset correctly")
   }
 
   func testOffsetPointTwoArg() {
-    let origin = offset(view.frame.origin, 1, 2)
+    let origin = offset(view.frame.origin, dx: 1, dy: 2)
     XCTAssertEqual(
       origin,
       CGPoint(x: 2, y: 5),