improved custom angle support on negative ranges and added tests

Author: MiaKoring

Sources/SwiftCrossUI/Values/Gradient.swift

@@ -5,6 +5,30 @@ public struct Gradient {
 
     /// Creates a gradient from an array of color stops.
     init(stops: [Gradient.Stop]) {
+        guard
+            let first = stops.first
+        else {
+            let invisible = Color.black.opacity(0)
+            self.stops = [
+                Stop(color: invisible, location: 0),
+                Stop(color: invisible, location: 1),
+            ]
+            return
+        }
+
+        #if DEBUG
+            if stops != stops.sorted(by: { $0.location < $1.location }) {
+                logger.warning("Gradient stop locations must be ordered")
+            }
+        #endif
+
+        if stops.count == 1 {
+            self.stops = [
+                Stop(color: first.color, location: 0),
+                Stop(color: first.color, location: 1),
+            ]
+            return
+        }
         self.stops = stops
     }
 
@@ -60,3 +84,5 @@ public struct Gradient {
         public var location: Double
     }
 }
+
+extension Gradient.Stop: Equatable {}

Sources/SwiftCrossUI/Views/Gradients/AngularGradient.swift

@@ -132,7 +132,7 @@ extension AngularGradient {
         let range = (endAngle - startAngle).degrees
 
         if range < 0 {
-            stops = stops.reversed().map {
+            stops = stops.map {
                 Gradient.Stop(color: $0.color, location: 1 - $0.location)
             }
         }
@@ -145,10 +145,6 @@ extension AngularGradient {
             Gradient.Stop(color: $0.color, location: $0.location * dividableRange)
         }
 
-        stops.append(
-            Gradient.Stop(color: stops.last!.color, location: 1)
-        )
-
-        return stops
+        return stops.sorted(by: { $0.location < $1.location })
     }
 }

Tests/SwiftCrossUITests/GradientTests.swift

@@ -2,6 +2,7 @@ import Testing
 @testable import SwiftCrossUI
 
 @Suite("Test Gradients")
+@MainActor
 struct GradientTests {
     @Test("Automatic equal distribution of color")
     func testAutomaticColorDistribution() async throws {
@@ -13,14 +14,9 @@ struct GradientTests {
 
         func checkExpectations(gradient: Gradient) {
             let count = Double(gradient.stops.count) - 1
-            print(count)
+    
             for (i, stop) in gradient.stops.enumerated() {
-                // Multiplied by 1 million before converting to Int
-                // to avoid floating point calculation/rounding errors
-                #expect(
-                        Int(stop.location * 1_000_000) ==
-                        Int((Double(i) / count) * 1_000_000)
-                    )
+                #expect(stop.location ~= (Double(i) / count))
             }
         }
     }
@@ -40,8 +36,6 @@ struct GradientTests {
     func testSingleColorArrayCreates2Stops() async throws {
         let gradient = Gradient(colors: [.red])
 
-        print(gradient.stops)
-        
         #expect(gradient.stops.count == 2)
         #expect(gradient.stops.first!.color == .red)
         #expect(gradient.stops.first!.location == 0)
@@ -66,4 +60,104 @@ struct GradientTests {
             #expect(colors[i] == stop.color)
         }
     }
+    
+    @Test("AngularGradient: Unspecified end angle returns original stops")
+    func nilEndAngleReturnsOriginalStops() async throws {
+        let gradient = AngularGradient(
+            stops: [
+                .init(color: .red, location: 0),
+                .init(color: .blue, location: 1)
+            ],
+            center: .center,
+            angle: .degrees(45)
+        )
+        
+        let result = gradient.adjustedStops
+        
+        #expect(gradient.endAngle == nil)
+        #expect(result == gradient.gradient.stops)
+    }
+    
+    @Test("AngularGradient: Positive range scales correctly")
+    func positiveRangeScalesCorrectly() async throws {
+        let gradient = AngularGradient(
+            stops: [
+                .init(color: .red, location: 0),
+                .init(color: .blue, location: 0.5),
+                .init(color: .green, location: 1)
+            ],
+            center: .center,
+            startAngle: .degrees(0),
+            endAngle: .degrees(180)
+        )
+        
+        let result = gradient.adjustedStops
+        
+        #expect(result[0].location == 0)
+        #expect(result[1].location ~= 0.25)
+        #expect(result[2].location ~= 0.5)
+    }
+    
+    @Test("AngularGradient: Negative range inverts locations")
+    func negativeRangeReversesAndInverts() async throws {
+        let gradient = AngularGradient(
+            stops: [
+                .init(color: .red, location: 0),
+                .init(color: .blue, location: 0.5),
+                .init(color: .green, location: 1)
+            ],
+            center: .center,
+            startAngle: .degrees(180),
+            endAngle: .degrees(0)
+        )
+        
+        let result = gradient.adjustedStops
+        
+        #expect(result[0].color == .green)
+        #expect(result[0].location ~= 0)
+        #expect(result[1].location ~= 0.25)
+        #expect(result[2].location ~= 0.5)
+    }
+    
+    @Test("AngularGradient: Full circle range")
+    func fullCircleRange() async throws {
+        let gradient = AngularGradient(
+            stops: [
+                .init(color: .red, location: 0),
+                .init(color: .blue, location: 1)
+            ],
+            center: .center,
+            startAngle: .degrees(0),
+            endAngle: .degrees(360)
+        )
+        
+        let result = gradient.adjustedStops
+        
+        #expect(result[0].location == 0)
+        #expect(result[1].location ~= 1.0)
+    }
+    
+    @Test("Final Color matches last Original")
+    func finalColorMatchesLastOriginal() async throws {
+        let gradient = AngularGradient(
+            stops: [
+                .init(color: .red, location: 0),
+                .init(color: .blue, location: 1)
+            ],
+            center: .center,
+            startAngle: .degrees(0),
+            endAngle: .degrees(180)
+        )
+        
+        let result = gradient.adjustedStops
+        
+        #expect(result.last?.color == .blue)
+    }
+}
+
+fileprivate extension Double {
+    static func ~= (lhs: Self, rhs: Self) -> Bool {
+        Int(lhs * 1_000_000_000) ==
+        Int(rhs * 1_000_000_000)
+    }
 }