Adding location tests

Author: swhitty

SwiftDraw/LayerTree.A.Path.swift

@@ -53,3 +53,52 @@ extension LayerTree {
         }
     }
 }
+
+extension LayerTree.Path {
+    var lastControl: LayerTree.Point? {
+        guard let lastSegment = segments.last else { return nil }
+        switch lastSegment {
+        case .cubic(_, _, let p): return p
+        default: return nil
+        }
+    }
+
+    var location: LayerTree.Point? {
+        guard let location = segments.last?.location else {
+            return lastStart
+        }
+
+        return location
+    }
+
+    var lastStart: LayerTree.Point? {
+        let rev = segments.reversed().dropFirst()
+        guard
+            let closeIdx = rev.index(where: { $0.isClose }),
+            closeIdx != rev.startIndex else {
+                return segments.first?.location
+        }
+
+        let point = rev.index(before: closeIdx)
+        return rev[point].location
+    }
+}
+
+private extension LayerTree.Path.Segment {
+
+    var isClose: Bool {
+        guard case .close = self else {
+            return false
+        }
+        return true
+    }
+
+    var location: LayerTree.Point? {
+        switch self {
+        case .move(to: let p): return p
+        case .line(let p): return p
+        case .cubic(let p, _, _): return p
+        case .close: return nil
+        }
+    }
+}

SwiftDraw/LayerTree.Builder.Path.swift

@@ -43,7 +43,7 @@ extension LayerTree.Builder {
 
         for s in element.segments {
             let segment = try createSegment(from: s,
-                                            last: path.last ?? Point.zero,
+                                            last: path.location ?? Point.zero,
                                             previous: path.lastControl)
             path.segments.append(segment)
         }
@@ -224,52 +224,3 @@ extension LayerTree.Point {
         return LayerTree.Point(base.x + x, base.y + y)
     }
 }
-
-extension LayerTree.Path {
-    var lastControl: LayerTree.Point? {
-        guard let lastSegment = segments.last else { return nil }
-        switch lastSegment {
-        case .cubic(_, _, let p): return p
-        default: return nil
-        }
-    }
-    
-    var last: LayerTree.Point? {
-        guard let last = segments.last?.last else {
-            return lastStart
-        }
-
-        return last
-    }
-
-    var lastStart: LayerTree.Point? {
-        let rev = segments.reversed().dropFirst()
-        guard
-            let closeIdx = rev.index(where: { $0.isClose }),
-            closeIdx != rev.startIndex else {
-                return segments.first?.last
-        }
-
-        let point = rev.index(before: closeIdx)
-        return rev[point].last
-    }
-}
-
-private extension LayerTree.Path.Segment {
-
-    var isClose: Bool {
-        guard case .close = self else {
-            return false
-        }
-        return true
-    }
-
-    var last: LayerTree.Point? {
-        switch self {
-        case .move(to: let p): return p
-        case .line(let p): return p
-        case .cubic(let p, _, _): return p
-        case .close: return nil
-        }
-    }
-}

SwiftDrawTests/LayerTree.PathTests.swift

@@ -38,6 +38,24 @@ final class LayerTreePathTests: XCTestCase {
 
     let twoThirds = Float(2.0/3.0)
 
+
+    func testLocation() {
+        let path = Path()
+        XCTAssertNil(path.location)
+
+        path.segments.append(move(110, 90))
+        XCTAssertEqual(path.location, Point(110, 90))
+
+        path.segments.append(line(200, 200))
+        XCTAssertEqual(path.location, Point(200, 200))
+
+        path.segments.append(.cubic(to: Point(300, 300), control1: Point(200, 200), control2: Point(250, 250)))
+        XCTAssertEqual(path.location, Point(300, 300))
+
+        path.segments.append(.close)
+        XCTAssertEqual(path.location, Point(110, 90))
+    }
+
     func testMove() {
 
         var m = LayerTree.Builder.createMove(from: .move(x: 10, y: 10, space: .absolute), last: .zero)