Add SwiftUI modifiers, basic geometry tests

Author: mark-onyschuk

README.md

@@ -1,9 +1,13 @@
 # Geometry
-A repository of common geometric algorithms and `CoreGraphics` type extensions.
+A repository of common geometric algorithms, `SwiftUI` and `CoreGraphics` type extensions.
 
 ## Algorithms
 At present, the package contains no algorithms.
 
+##  `SwiftUI` Extensions
+Geometry defines a `FrameReader` extension used to more easily gather geometry
+from a SwiftUI view hierarchy.
+
 ## `CoreGraphics` Extensions
 Geometry defines `CGVectorType` a protocol unifying the various 2D CoreGraphics
 types including `CGPoint`, `CGSize`, and `CGVector`. The type provides support for
@@ -12,4 +16,12 @@ easy conversion among types.
 The type also allows for a concise definition of standard operators for addition, 
 subtraction, multiplication, and division involving `CGVectorType` types.
 
-Finally, the package includes several extensions to `CGRect`.
+Finally, the package includes several extensions to `CGRect`:
+
+```swift
+// fetch point at min X, mid Y
+let midLeft = rect.at(.min, .mid)
+
+// fetch the midpoint
+let bottomRight = rect.at(.max, .max)
+```

Sources/Geometry/CoreGraphics.swift …s/Geometry/Extensions/CoreGraphics.swiftSources/Geometry/CoreGraphics.swift renamed to Sources/Geometry/Extensions/CoreGraphics.swift Sources/Geometry/CoreGraphics.swift renamed to Sources/Geometry/Extensions/CoreGraphics.swift

@@ -144,6 +144,20 @@ extension CGVector: CGVectorType {
 }
 
 extension CGRect {
+    /// Initializes a `CGRect` from one or more points
+    /// - Parameter points: a list of one or more points
+    public init(_ points: CGVectorType...) {
+        let xs   = points.map(\.dx)
+        let ys   = points.map(\.dy)
+        
+        let xmin = xs.min() ?? xs[0]
+        let xmax = xs.max() ?? xs[0]
+        let ymin = ys.min() ?? ys[0]
+        let ymax = ys.max() ?? ys[0]
+
+        self.init(x: xmin, y: ymin, width: xmax - xmin, height: ymax - ymin)
+    }
+    
     public struct Position: Hashable, Codable {
         let value: CGFloat
         private init(_ value: CGFloat) {

Sources/Geometry/SwiftUI View Modifiers/FrameReader.swift

@@ -0,0 +1,72 @@
+//
+//  FrameReader.swift
+//  Geometry
+//
+//  Created by Mark Onyschuk on 12/04/23.
+//  Copyright © 2023 Dimension North Inc. All rights reserved.
+//
+
+import SwiftUI
+
+private struct FrameReader: ViewModifier {
+    struct Frame: PreferenceKey {
+        static var defaultValue: CGRect = .zero
+        static func reduce(value: inout CGRect, nextValue: () -> CGRect) {}
+    }
+
+    var onChange: (CGRect) -> ()
+    var coordinates: CoordinateSpace
+
+    init(coordinates: CoordinateSpace, onChange: @escaping (CGRect) -> ()) {
+        self.onChange = onChange
+        self.coordinates = coordinates
+    }
+
+    public func body(content: Content) -> some View {
+        content.overlay(GeometryReader {
+            geom in
+            Color.clear.preference(
+                key: Frame.self,
+                value: geom.frame(in: coordinates)
+            )
+        })
+        .onPreferenceChange(Frame.self, perform: onChange)
+    }
+}
+
+extension View {
+    
+    /// An extension whose  `value` tracks the enclosed view's bounding rectangle in `coordinates`
+    /// - Parameters:
+    ///   - value: a `CGRect` binding
+    ///   - coordinates: a coordinate space
+    /// - Returns: a modified view
+    public func rect(_ value: Binding<CGRect>, in coordinates: CoordinateSpace = .global) -> some View {
+        self.modifier(FrameReader(coordinates: coordinates) {
+            value.wrappedValue = $0
+        })
+    }
+
+    /// An extension whose  `value` tracks the enclosed view's size in `coordinates`
+    /// - Parameters:
+    ///   - value: a `CGSize` binding
+    ///   - coordinates: a coordinate space
+    /// - Returns: a modified view
+    public func size(_ value: Binding<CGSize>, in coordinates: CoordinateSpace = .global) -> some View {
+        self.modifier(FrameReader(coordinates: coordinates) {
+            value.wrappedValue = $0.size
+        })
+    }
+
+    /// An extension whose  `value` tracks the enclosed view's origin in `coordinates`
+    /// - Parameters:
+    ///   - value: a `CGPoint` binding
+    ///   - coordinates: a coordinate space
+    /// - Returns: a modified view
+    public func origin(_ value: Binding<CGPoint>, in coordinates: CoordinateSpace = .global) -> some View {
+        self.modifier(FrameReader(coordinates: coordinates) {
+            value.wrappedValue = $0.origin
+        })
+    }
+}
+

Tests/GeometryTests/GeometryTests.swift

@@ -1,12 +1,56 @@
 import XCTest
 @testable import Geometry
 
-final class GeometryTests: XCTestCase {
-    func testExample() throws {
-        // XCTest Documentation
-        // https://developer.apple.com/documentation/xctest
+final class CGRectTests: XCTestCase {
+    func testItReturnsLocationsWithinIt() {
+        let r1 = CGRect(origin: .init(0, 0), size: .init(100, 100))
+        
+        XCTAssert(r1.at(.min, .min) == CGPoint(0, 0))
+        XCTAssert(r1.at(.max, .max) == CGPoint(100, 100))
+        XCTAssert(r1.at(.mid, .max) == CGPoint(50, 100))
+    }
+    
+    func testItCanBeInitializedFromPoints() {
+        let p0 = CGPoint(0, 0)
+        let p1 = CGPoint(50, 50)
+        let p2 = CGPoint(100, 100)
+        
+        let r1 = CGRect(p0)
+        
+        XCTAssert(r1.origin == p0)
+        XCTAssert(r1.size   == .zero)
+        
+        let r2 = CGRect(p0, p1)
+        
+        XCTAssert(r2.origin == p0)
+        XCTAssert(r2.size == CGSize(p1 - p0))
+        
+        let r3 = CGRect(p0, p1, p2)
+        
+        XCTAssert(r3.origin == p0)
+        XCTAssert(r3.size == CGSize(p2 - p0))
+        
+        XCTAssert(r3.contains(p1))
+    }
+}
 
-        // Defining Test Cases and Test Methods
-        // https://developer.apple.com/documentation/xctest/defining_test_cases_and_test_methods
+final class CGVectorTypeTests: XCTestCase {
+    func testVectorTypesCanBeConverted() {
+        let p1 = CGPoint(1, 2)
+        let s2 = CGSize(p1)
+        
+        XCTAssert(s2.width == 1 && s2.height == 2)
+    }
+    
+    func testVectorTypesOfferCommonOperators() {
+        let s1 = CGSize(100, 100)
+        
+        XCTAssert(s1 * 2 == CGSize(200, 200))
+        XCTAssert(s1 + (0, 5) == CGSize(100, 105))
+        XCTAssert(s1 * (1, 0.5) == CGSize(100, 50))
+        
+        XCTAssert(s1 / 2 == CGSize(50, 50))
+        XCTAssert(s1 - (0, 5) == CGSize(100, 95))
+        XCTAssert(s1 / (1, 0.5) == CGSize(100, 100))
     }
 }