round up logic, and tests - some failing

Author: heckj

Sources/SwiftVizScale/NiceValue.swift

@@ -236,14 +236,34 @@ public enum DateMagnitude: Equatable {
     case months
     /// Years.
     case years
-
+    
     static let subsecondThreshold: PartialRangeUpTo<Double> = ..<1
     static let secondsThreshold: Range<Double> = 1 ..< 60
     static let minutesThreshold: Range<Double> = 60 ..< 60 * 60
     static let hoursThreshold: Range<Double> = 60 * 60 ..< 60 * 60 * 24
     static let daysThreshold: Range<Double> = 60 * 60 * 24 ..< 60 * 60 * 24 * 28
     static let monthsThreshold: Range<Double> = 60 * 60 * 24 * 28 ..< 60 * 60 * 24 * 365
     static let yearsThreshold: PartialRangeFrom<Double> = (60 * 60 * 24 * 365)...
+    
+    /// The value of the date magnitude in seconds per increment.
+    public var seconds: Double {
+        switch self {
+        case .subsecond:
+            return 0
+        case .seconds:
+            return 1
+        case .minutes:
+            return DateMagnitude.minutesThreshold.lowerBound
+        case .hours:
+            return DateMagnitude.hoursThreshold.lowerBound
+        case .days:
+            return DateMagnitude.daysThreshold.lowerBound
+        case .months:
+            return DateMagnitude.monthsThreshold.lowerBound
+        default:
+            return DateMagnitude.yearsThreshold.lowerBound
+        }
+    }
 
     public static func magnitudeOfDateRange(_ lhs: Date, _ rhs: Date) -> DateMagnitude {
         let dateExtentMagnitude = abs(lhs.timeIntervalSinceReferenceDate - rhs.timeIntervalSinceReferenceDate)
@@ -269,7 +289,7 @@ public enum DateMagnitude: Equatable {
 public extension Date {
     /// Returns a Date value rounded down to the next nice "date" value based on a calendar, and optionally the step size of the range.
     /// - Parameters:
-    ///   - magnitude: The magnitude to which to round
+    ///   - magnitude: The magnitude to which to round.
     ///   - calendar: The calendar to use to compute the next lower value.
     ///   - stepSize: The nice step size, in seconds, for the date increments.
     func round(magnitude: DateMagnitude, calendar: Calendar, stepSize: Double? = nil) -> Self? {
@@ -347,7 +367,22 @@ public extension Date {
             return components.date
         }
     }
-
+    
+    /// Returns a date based on the current value, rounded 'up' to the next incremental step value.
+    /// - Parameters:
+    ///   - magnitude: The magnitude to which to round.
+    ///   - calendar: The calendar to use to compute the next lower value.
+    ///   - stepSize: The nice step size, in seconds, for the date increments.
+    func roundUp(magnitude: DateMagnitude, calendar: Calendar, stepSize: Double? = nil) -> Self? {
+        let incDate: Date
+        if let stepSize = stepSize, stepSize >= magnitude.seconds {
+            incDate = self+stepSize
+        } else {
+            incDate = self+magnitude.seconds
+        }
+        return incDate.round(magnitude: magnitude, calendar: calendar, stepSize: stepSize)
+    }
+    
     /// Returns a nice step size for the magnitude of date range you provide.
     /// - Parameters:
     ///   - step: The step size (in seconds) for the date increment.

Tests/SwiftVizScaleTests/DateNiceValueTests.swift

@@ -179,6 +179,109 @@ final class DateNiceValueTests: XCTestCase {
         )
     }
 
+    func testCalendricalDateRoundUp_seconds() throws {
+        let (formatter, now) = formatterAndNow()
+        // starting position for comparison
+        XCTAssertEqual(formatter.string(from: now), "2022-08-08T22:43:09.011Z")
+
+        let result_1 = now.roundUp(magnitude: .seconds, calendar: testCal, stepSize: 1)
+        // step size of 1 is same result as not providing it for seconds
+        XCTAssertEqual(formatter.string(from: result_1!), "2022-08-08T22:43:10.000Z")
+
+        let result_2 = now.roundUp(magnitude: .seconds, calendar: testCal, stepSize: 2)
+        XCTAssertEqual(formatter.string(from: result_2!), "2022-08-08T22:43:10.000Z")
+
+        let result_5 = now.roundUp(magnitude: .seconds, calendar: testCal, stepSize: 5)
+        XCTAssertEqual(formatter.string(from: result_5!), "2022-08-08T22:43:10.000Z")
+    }
+
+    func testCalendricalDateRoundUp_minutes() throws {
+        let (formatter, now) = formatterAndNow()
+        // starting position for comparison
+        XCTAssertEqual(formatter.string(from: now), "2022-08-08T22:43:09.011Z")
+
+        XCTAssertEqual(
+            formatter.string(from: now.roundUp(magnitude: .minutes, calendar: testCal, stepSize: 1 * 60)!),
+            "2022-08-08T22:44:00.000Z"
+        )
+
+        XCTAssertEqual(
+            formatter.string(from: now.roundUp(magnitude: .minutes, calendar: testCal, stepSize: 2 * 60)!),
+            "2022-08-08T22:44:00.000Z"
+        )
+
+        XCTAssertEqual(
+            formatter.string(from: now.roundUp(magnitude: .minutes, calendar: testCal, stepSize: 5 * 60)!),
+            "2022-08-08T22:45:00.000Z"
+        )
+    }
+
+    func testCalendricalDateRoundUp_hours() throws {
+        let (formatter, now) = formatterAndNow()
+        // starting position for comparison
+        XCTAssertEqual(formatter.string(from: now), "2022-08-08T22:43:09.011Z")
+
+        XCTAssertEqual(
+            formatter.string(from: now.roundUp(magnitude: .hours, calendar: testCal, stepSize: 1 * 60 * 60)!),
+            "2022-08-08T23:00:00.000Z"
+        )
+
+        XCTAssertEqual(
+            formatter.string(from: now.round(magnitude: .hours, calendar: testCal, stepSize: 2 * 60 * 60)!),
+            "2022-08-09T00:00:00.000Z"
+        )
+
+        XCTAssertEqual(
+            formatter.string(from: now.round(magnitude: .hours, calendar: testCal, stepSize: 6 * 60 * 60)!),
+            "2022-08-09T00:00:00.000Z"
+        )
+    }
+
+    func testCalendricalDateRoundUp_days() throws {
+        let (formatter, now) = formatterAndNow()
+        // starting position for comparison
+        XCTAssertEqual(formatter.string(from: now), "2022-08-08T22:43:09.011Z")
+
+        XCTAssertEqual(
+            formatter.string(from: now.round(magnitude: .days, calendar: testCal, stepSize: 1 * 24 * 60 * 60)!),
+            "2022-08-09T00:00:00.000Z"
+        )
+
+        XCTAssertEqual(
+            formatter.string(from: now.round(magnitude: .days, calendar: testCal, stepSize: 2 * 24 * 60 * 60)!),
+            "2022-08-10T00:00:00.000Z"
+        )
+
+        // NOTE(heckj): This is rounding down to the 7th day of the month rather than to a specific "day of week"
+        // and we might want to choose the other path in terms of "nice values" that are spanning 7 day (week)
+        // increments.
+        XCTAssertEqual(
+            formatter.string(from: now.round(magnitude: .days, calendar: testCal, stepSize: 7 * 24 * 60 * 60)!),
+            "2022-08-15T00:00:00.000Z"
+        )
+    }
+
+    func testCalendricalDateRoundUp_months() throws {
+        let (formatter, now) = formatterAndNow()
+        // starting position for comparison
+        XCTAssertEqual(formatter.string(from: now), "2022-08-08T22:43:09.011Z")
+
+        XCTAssertEqual(
+            formatter.string(from: now.round(magnitude: .months, calendar: testCal, stepSize: 1 * 28 * 24 * 60 * 60)!),
+            "2022-09-01T00:00:00.000Z"
+        )
+
+        XCTAssertEqual(
+            formatter.string(from: now.round(magnitude: .months, calendar: testCal, stepSize: 2 * 28 * 24 * 60 * 60)!),
+            "2022-09-01T00:00:00.000Z"
+        )
+
+        XCTAssertEqual(
+            formatter.string(from: now.round(magnitude: .months, calendar: testCal, stepSize: 6 * 28 * 24 * 60 * 60)!),
+            "2022-12-01T00:00:00.000Z"
+        )
+    }
+
     func testNiceStepForDateMagnitudes_subseconds() throws {
         XCTAssertEqual(Date.niceStepForMagnitude(step: 0.10, magnitude: .subsecond), 0.1)
         XCTAssertEqual(Date.niceStepForMagnitude(step: 0.11, magnitude: .subsecond), 0.2)