Decode cadence from zwo files

Author: michallaskowski

Diff for: Sources/FitWorkoutDecoder/FitWorkoutDecoder.swift

@@ -61,13 +61,15 @@ public final class FitWorkoutDecoder: WorkoutDecoding {
             switch stepsDistance {
             case 0:
                 let workoutStep = workoutSteps[repeatStep.range.lowerBound]
-                return WorkoutPart.steady(duration: workoutStep.duration, power: workoutStep.power(for: userFtp))
+                return WorkoutPart.steady(duration: workoutStep.duration, power: workoutStep.power(for: userFtp),
+                                          cadence: nil)
             case 1:
                 let firstWorkoutStep = workoutSteps[repeatStep.range.lowerBound]
                 let secondWorkoutStep = workoutSteps[repeatStep.range.upperBound]
                 return WorkoutPart.intervals(repeat: repeatStep.repeatCount,
                                              onDuration: firstWorkoutStep.duration, onPower: firstWorkoutStep.power(for: userFtp),
-                                             offDuration: secondWorkoutStep.duration, offPower: secondWorkoutStep.power(for: userFtp))
+                                             offDuration: secondWorkoutStep.duration, offPower: secondWorkoutStep.power(for: userFtp),
+                                             cadence: nil)
             default:
                 throw FitDecodeError.notSupportedRange
             }

Diff for: Sources/WorkoutDecoderBase/WorkoutDecoding.swift

@@ -13,30 +13,32 @@ public protocol WorkoutDecoding {
 }
 
 public enum WorkoutPart {
-    case steady(duration: Int, power: Double)
-    case intervals(repeat: Int, onDuration: Int, onPower: Double, offDuration: Int, offPower: Double)
-    case ramp(duration: Int, powerLow: Double, powerHigh: Double)
-    case freeRide(duration: Int)
+    case steady(duration: Int, power: Double, cadence: String?)
+    case intervals(repeat: Int, onDuration: Int, onPower: Double, offDuration: Int, offPower: Double, cadence: String?)
+    case ramp(duration: Int, powerLow: Double, powerHigh: Double, cadence: String?)
+    case freeRide(duration: Int, cadence: String?)
 
     public func toSegments(startIndex: Int) -> [WorkoutSegment] {
         switch self {
-        case .steady(let duration, let power):
-            return [WorkoutSegment(duration: duration, index: startIndex, intervalIndex: nil, powerStart: power, powerEnd: nil)]
-        case .intervals(let repeats, let onDuration, let onPower, let offDuration, let offPower):
+        case .steady(let duration, let power, let cadence):
+            return [WorkoutSegment(duration: duration, index: startIndex, intervalIndex: nil,
+                                   powerStart: power, powerEnd: nil, cadence: cadence)]
+        case .intervals(let repeats, let onDuration, let onPower, let offDuration, let offPower, let cadence):
             return (0..<repeats).map { index -> [WorkoutSegment] in
                 [
                     WorkoutSegment(duration: onDuration, index: startIndex + index * 2,
-                                   intervalIndex: index, powerStart: onPower, powerEnd: nil),
+                                   intervalIndex: index, powerStart: onPower, powerEnd: nil, cadence: cadence),
                     WorkoutSegment(duration: offDuration, index: startIndex + index * 2 + 1,
-                                   intervalIndex: index, powerStart: offPower, powerEnd: nil),
+                                   intervalIndex: index, powerStart: offPower, powerEnd: nil, cadence: cadence)
                 ]
             }.flatMap { $0 }
 
-        case .ramp(let duration, let powerLow, let powerHigh):
+        case .ramp(let duration, let powerLow, let powerHigh, let cadence):
             return [WorkoutSegment(duration: duration, index: startIndex,
-                                   intervalIndex: nil, powerStart: powerLow, powerEnd: powerHigh)]
-        case .freeRide(let duration):
-            return [WorkoutSegment(duration: duration, index: startIndex, intervalIndex: nil, powerStart: -1.0, powerEnd: nil)]
+                                   intervalIndex: nil, powerStart: powerLow, powerEnd: powerHigh, cadence: cadence)]
+        case .freeRide(let duration, let cadence):
+            return [WorkoutSegment(duration: duration, index: startIndex, intervalIndex: nil,
+                                   powerStart: -1.0, powerEnd: nil, cadence: cadence)]
         }
     }
 }
@@ -47,6 +49,7 @@ public struct WorkoutSegment: Codable, Equatable {
     public let intervalIndex: Int?
     public let powerStart: Double // negative power means free ride
     public let powerEnd: Double?
+    public let cadence: String?
 
     public func powerAt(second: Int, for ftp: Double) -> Int {
         let power: Double

Diff for: Sources/ZwoWorkoutDecoder/ZwoWorkoutDecoder.swift

@@ -20,22 +20,27 @@ public final class ZwoWorkoutDecoder: WorkoutDecoding {
         let name: String = workout["name"].text ?? "no_name"
         let parts = try workout["workout"].element?.childElements.map { part -> WorkoutPart in
             let attributes = part.attributes
+            let cadence = attributes["Cadence"]
             switch part.name {
             case "SteadyState":
                 return WorkoutPart.steady(duration: attributes.int("Duration"),
-                                          power: Double(attributes["Power"]!)!)
+                                          power: attributes.double("Power"),
+                                          cadence: cadence)
             case "IntervalsT":
                 return WorkoutPart.intervals(repeat: attributes.int("Repeat"),
                                              onDuration: attributes.int("OnDuration"),
-                                             onPower: Double(attributes["OnPower"]!)!,
+                                             onPower: attributes.double("OnPower"),
                                              offDuration: attributes.int("OffDuration"),
-                                             offPower: Double(attributes["OffPower"]!)!)
+                                             offPower: attributes.double("OffPower"),
+                                             cadence: cadence)
             case "Warmup", "Cooldown", "Ramp":
                 return WorkoutPart.ramp(duration: attributes.int("Duration"),
-                                        powerLow: Double(attributes["PowerLow"]!)!,
-                                        powerHigh: Double(attributes["PowerHigh"]!)!)
+                                        powerLow: attributes.double("PowerLow"),
+                                        powerHigh: attributes.double("PowerHigh"),
+                                        cadence: cadence)
             case "FreeRide":
-                return WorkoutPart.freeRide(duration: attributes.int("Duration"))
+                return WorkoutPart.freeRide(duration: attributes.int("Duration"),
+                                            cadence: cadence)
             default:
                 throw WorkoutDecodeError.unknownElement(name: part.name)
             }
@@ -87,4 +92,10 @@ private extension Dictionary where Value == String {
             Int($0)
         } ?? fallback
     }
+
+    func double(_ key: Key, fallback: Double = 0.0) -> Double {
+        return self[key].flatMap {
+            Double($0)
+        } ?? fallback
+    }
 }

Diff for: Tests/WorkoutDecodersTests/Resources/workout1.zwo

@@ -8,8 +8,8 @@
         <Warmup Duration="10" PowerLow="0.5" PowerHigh="0.55">
            <textevent timeoffset="0" message="Starting message"/>
         </Warmup>
-		<SteadyState Duration="5" Power="0.4"/>
-        <FreeRide Duration="100"/>
+		<SteadyState Duration="5" Power="0.4" Cadence="100"/>
+        <FreeRide Duration="100" Cadence="90"/>
 		<SteadyState Duration="10" Power="0.5">
             <textevent timeoffset="5" message="Should be at offset 120"/>
         </SteadyState>

Diff for: Tests/WorkoutDecodersTests/WorkoutDecodersTests.swift

@@ -17,19 +17,19 @@ final class WorkoutDecodersTests: XCTestCase {
         let workout = decodedWorkout()
 
         XCTAssertEqual(workout.segments, [
-            WorkoutSegment(duration: 10, index: 0, intervalIndex: nil, powerStart: 0.5, powerEnd: 0.55),
-            WorkoutSegment(duration: 5, index: 1, intervalIndex: nil, powerStart: 0.4, powerEnd: nil),
-            WorkoutSegment(duration: 100, index: 2, intervalIndex: nil, powerStart: -1, powerEnd: nil), // free ride
-            WorkoutSegment(duration: 10, index: 3, intervalIndex: nil, powerStart: 0.5, powerEnd: nil),
+            WorkoutSegment(duration: 10, index: 0, intervalIndex: nil, powerStart: 0.5, powerEnd: 0.55, cadence: nil),
+            WorkoutSegment(duration: 5, index: 1, intervalIndex: nil, powerStart: 0.4, powerEnd: nil, cadence: "100"),
+            WorkoutSegment(duration: 100, index: 2, intervalIndex: nil, powerStart: -1, powerEnd: nil, cadence: "90"), // free ride
+            WorkoutSegment(duration: 10, index: 3, intervalIndex: nil, powerStart: 0.5, powerEnd: nil, cadence: nil),
             // interval start, repeat 3
-            WorkoutSegment(duration: 15, index: 4, intervalIndex: 0, powerStart: 1.2, powerEnd: nil),
-            WorkoutSegment(duration: 5, index: 5, intervalIndex: 0, powerStart: 0.4, powerEnd: nil),
-            WorkoutSegment(duration: 15, index: 6, intervalIndex: 1, powerStart: 1.2, powerEnd: nil),
-            WorkoutSegment(duration: 5, index: 7, intervalIndex: 1, powerStart: 0.4, powerEnd: nil),
-            WorkoutSegment(duration: 15, index: 8, intervalIndex: 2, powerStart: 1.2, powerEnd: nil),
-            WorkoutSegment(duration: 5, index: 9, intervalIndex: 2, powerStart: 0.4, powerEnd: nil),
+            WorkoutSegment(duration: 15, index: 4, intervalIndex: 0, powerStart: 1.2, powerEnd: nil, cadence: nil),
+            WorkoutSegment(duration: 5, index: 5, intervalIndex: 0, powerStart: 0.4, powerEnd: nil, cadence: nil),
+            WorkoutSegment(duration: 15, index: 6, intervalIndex: 1, powerStart: 1.2, powerEnd: nil, cadence: nil),
+            WorkoutSegment(duration: 5, index: 7, intervalIndex: 1, powerStart: 0.4, powerEnd: nil, cadence: nil),
+            WorkoutSegment(duration: 15, index: 8, intervalIndex: 2, powerStart: 1.2, powerEnd: nil, cadence: nil),
+            WorkoutSegment(duration: 5, index: 9, intervalIndex: 2, powerStart: 0.4, powerEnd: nil, cadence: nil),
             // interval end
-            WorkoutSegment(duration: 5, index: 10, intervalIndex: nil, powerStart: 0.6, powerEnd: nil)
+            WorkoutSegment(duration: 5, index: 10, intervalIndex: nil, powerStart: 0.6, powerEnd: nil, cadence: nil)
         ])
     }