chore: clean up whitespace and minor optimizations

Author: philocalyst

Rectangle/CycleSize.swift

@@ -8,18 +8,18 @@ enum CycleSize: Int, CaseIterable {
     case oneThird = 2
     case oneQuarter = 3
     case threeQuarters = 4
-    
+
     static func fromBits(bits: Int) -> Set<CycleSize> {
         Set(
             Self.allCases.filter {
                 (bits >> $0.rawValue) & 1 == 1
             }
         )
     }
-    
+
     static var firstSize = CycleSize.oneHalf
     static var defaultSizes: Set<CycleSize> = [.oneHalf, .twoThirds, .oneThird]
-    
+
     // The expected order of the cycle sizes is to start with the
     // first division, then go gradually upwards in size and wrap
     // around to the smaller sizes.
@@ -28,14 +28,14 @@ enum CycleSize: Int, CaseIterable {
     // 1/2, 2/3, 3/4, 1/4, 1/3
     static var sortedSizes: [CycleSize] = {
         let sortedSizes = Self.allCases.sorted(by: { $0.fraction < $1.fraction })
-        
+
         guard let firstSizeIndex = sortedSizes.firstIndex(of: firstSize) else {
             return sortedSizes
         }
-        
+
         let lessThanFistSizes = sortedSizes[0..<firstSizeIndex]
         let greaterThanFistSizes = sortedSizes[(firstSizeIndex + 1)..<sortedSizes.count]
-        
+
         return [firstSize] + greaterThanFistSizes + lessThanFistSizes
     }()
 }
@@ -51,34 +51,24 @@ extension CycleSize {
     static func matching(percentValue: Float) -> CycleSize? {
         sortedSizes.first { $0.matches(percentValue: percentValue) }
     }
-    
+
     var title: String {
         switch self {
-        case .twoThirds:
-            "⅔"
-        case .oneHalf:
-            "½"
-        case .oneThird:
-            "⅓"
-        case .oneQuarter:
-            "¼"
-        case .threeQuarters:
-            "¾"
+        case .twoThirds:     return "⅔"
+        case .oneHalf:       return "½"
+        case .oneThird:      return "⅓"
+        case .oneQuarter:    return "¼"
+        case .threeQuarters: return "¾"
         }
     }
-    
+
     var fraction: Float {
         switch self {
-        case .twoThirds:
-            2 / 3
-        case .oneHalf:
-            1 / 2
-        case .oneThird:
-            1 / 3
-        case .oneQuarter:
-            1 / 4
-        case .threeQuarters:
-            3 / 4
+        case .twoThirds:     return 2 / 3
+        case .oneHalf:       return 1 / 2
+        case .oneThird:      return 1 / 3
+        case .oneQuarter:    return 1 / 4
+        case .threeQuarters: return 3 / 4
         }
     }
 
@@ -90,10 +80,8 @@ extension CycleSize {
         abs(self.percentValue - percentValue) <= tolerance
     }
 
-    var isAlwaysEnabled: Bool {
-        self == .firstSize
-    }
-    
+    var isAlwaysEnabled: Bool { self == .firstSize }
+
 }
 
 extension Set where Element == CycleSize {
@@ -109,15 +97,15 @@ extension Set where Element == CycleSize {
 class CycleSizesDefault: Default {
     public private(set) var key: String = "selectedCycleSizes"
     private var initialized = false
-    
+
     var value: Set<CycleSize> {
         didSet {
             if initialized {
                 PreferencesStore.shared.set(value.toBits(), forKey: key)
             }
         }
     }
-    
+
     init() {
         let bits = PreferencesStore.shared.int(forKey: key)
         value = CycleSize.fromBits(bits: bits)
@@ -130,7 +118,7 @@ class CycleSizesDefault: Default {
             value = divisions
         }
     }
-    
+
     func toCodable() -> CodableDefault {
         CodableDefault(int: value.toBits())
     }

Rectangle/SubsequentExecutionMode.swift

@@ -14,21 +14,21 @@ enum SubsequentExecutionMode: Int {
 class SubsequentExecutionDefault: Default {
     public private(set) var key: String = "subsequentExecutionMode"
     private var initialized = false
-    
+
     var value: SubsequentExecutionMode {
         didSet {
             if initialized {
                 PreferencesStore.shared.set(value.rawValue, forKey: key)
             }
         }
     }
-    
+
     init() {
         let intValue = PreferencesStore.shared.int(forKey: key)
         value = SubsequentExecutionMode(rawValue: intValue) ?? .resize
         initialized = true
     }
-    
+
     var resizes: Bool {
         switch value {
         case .resize, .acrossAndResize, .resizeAndCycleQuadrants: return true
@@ -56,7 +56,7 @@ class SubsequentExecutionDefault: Default {
             value = mode
         }
     }
-    
+
     func toCodable() -> CodableDefault {
         CodableDefault(int: value.rawValue)
     }

Rectangle/Utilities/MASShortcutMigration.swift

@@ -3,12 +3,16 @@
 import Foundation
 import MASShortcut
 
+/// One-time migration from the old NSData-encoded shortcut format to the
+/// current NSDictionary format stored via ShortcutStore.
 enum MASShortcutMigration {
 
     static func migrate() {
+        guard let dataTransformer = ValueTransformer(forName: .secureUnarchiveFromDataTransformerName)
+        else { return }
+
         for action in WindowAction.active {
             if let dataValue = PreferencesStore.shared.data(forKey: action.name),
-               let dataTransformer = ValueTransformer(forName: .secureUnarchiveFromDataTransformerName),
                let shortcut = dataTransformer.transformedValue(dataValue) as? MASShortcut {
                 ShortcutStore.setShortcut(shortcut, forKey: action.name)
             }