Migrates codebase to Swift 3.0

Author: Emily Toop

.swiftlint.yml

@@ -22,12 +22,24 @@ disabled_rules: # rule identifiers to exclude from running
   - operator_whitespace
   - file_length
   - mark
+  - unused_closure_parameter
+  - empty_parentheses_with_trailing_closure
+  - redundant_string_enum_value
+  - large_tuple
+  - vertical_parameter_alignment
+  - class_delegate_protocol
+  - syntactic_sugar
+  - implicit_getter
+  - weak_delegate
+  - shorthand_operator
+  - trailing_comma
 opt_in_rules: # some rules are only opt-in
   - closing_brace
   - opening_brace
   - return_arrow_whitespace
   - trailing_semicolon
   - statement_position
+  - explicit_init
   # Find all the available rules by running:
   # swiftlint rules
 included: # paths to include during linting. `--path` is ignored if present.

Account/FirefoxAccount.swift

@@ -6,6 +6,7 @@ import Foundation
 import Shared
 import XCGLogger
 import Deferred
+import SwiftyJSON
 
 private let log = Logger.syncLogger
 
@@ -20,31 +21,31 @@ let AccountSchemaVersion = 1
 ///
 /// Non-sensitive but persistent data should be maintained outside of
 /// the account itself.
-public class FirefoxAccount {
+open class FirefoxAccount {
     /// The email address identifying the account.  A Firefox Account is uniquely identified on a particular server
     /// (auth endpoint) by its email address.
-    public let email: String
+    open let email: String
 
     /// The auth endpoint user identifier identifying the account.  A Firefox Account is uniquely identified on a
     /// particular server (auth endpoint) by its assigned uid.
-    public let uid: String
+    open let uid: String
 
-    public var deviceRegistration: FxADeviceRegistration?
+    open var deviceRegistration: FxADeviceRegistration?
 
-    public let configuration: FirefoxAccountConfiguration
+    open let configuration: FirefoxAccountConfiguration
 
-    private let stateCache: KeychainCache<FxAState>
-    public var syncAuthState: SyncAuthState! // We can't give a reference to self if this is a let.
+    fileprivate let stateCache: KeychainCache<FxAState>
+    open var syncAuthState: SyncAuthState! // We can't give a reference to self if this is a let.
 
     // To prevent advance() consumers racing, we maintain a shared advance() deferred (`advanceDeferred`).  If an
     // advance() is in progress, the shared deferred will be returned.  (Multiple consumers can chain off a single
     // deferred safely.)  If no advance() is in progress, a new shared deferred will be scheduled and returned.  To
     // prevent data races against the shared deferred, advance() locks accesses to `advanceDeferred` using
     // `advanceLock`.
-    private var advanceLock = OSSpinLock()
-    private var advanceDeferred: Deferred<FxAState>? = nil
+    fileprivate var advanceLock = OSSpinLock()
+    fileprivate var advanceDeferred: Deferred<FxAState>?
 
-    public var actionNeeded: FxAActionNeeded {
+    open var actionNeeded: FxAActionNeeded {
         return stateCache.value!.actionNeeded
     }
 
@@ -63,34 +64,34 @@ public class FirefoxAccount {
             cache: KeychainCache.fromBranch("account.syncAuthState", withLabel: self.stateCache.label, factory: syncAuthStateCachefromJSON))
     }
 
-    public class func fromConfigurationAndJSON(configuration: FirefoxAccountConfiguration, data: JSON) -> FirefoxAccount? {
-        guard let email = data["email"].asString ,
-            let uid = data["uid"].asString,
-            let sessionToken = data["sessionToken"].asString?.hexDecodedData,
-            let keyFetchToken = data["keyFetchToken"].asString?.hexDecodedData,
-            let unwrapkB = data["unwrapBKey"].asString?.hexDecodedData else {
+    open class func from(_ configuration: FirefoxAccountConfiguration, andJSON data: JSON) -> FirefoxAccount? {
+        guard let email = data["email"].string ,
+            let uid = data["uid"].string,
+            let sessionToken = data["sessionToken"].string?.hexDecodedData,
+            let keyFetchToken = data["keyFetchToken"].string?.hexDecodedData,
+            let unwrapkB = data["unwrapBKey"].string?.hexDecodedData else {
                 return nil
         }
 
-        let verified = data["verified"].asBool ?? false
-        return FirefoxAccount.fromConfigurationAndParameters(configuration,
-            email: email, uid: uid, deviceRegistration: nil, verified: verified,
+        let verified = data["verified"].bool ?? false
+        return FirefoxAccount.from(configuration: configuration,
+            andParametersWithEmail: email, uid: uid, deviceRegistration: nil, verified: verified,
             sessionToken: sessionToken, keyFetchToken: keyFetchToken, unwrapkB: unwrapkB)
     }
 
-    public class func fromConfigurationAndLoginResponse(configuration: FirefoxAccountConfiguration,
-            response: FxALoginResponse, unwrapkB: NSData) -> FirefoxAccount {
-        return FirefoxAccount.fromConfigurationAndParameters(configuration,
-            email: response.remoteEmail, uid: response.uid, deviceRegistration: nil, verified: response.verified,
-            sessionToken: response.sessionToken, keyFetchToken: response.keyFetchToken, unwrapkB: unwrapkB)
+    open class func from(_ configuration: FirefoxAccountConfiguration,
+            andLoginResponse response: FxALoginResponse, unwrapkB: Data) -> FirefoxAccount {
+        return FirefoxAccount.from(configuration: configuration,
+            andParametersWithEmail: response.remoteEmail, uid: response.uid, deviceRegistration: nil, verified: response.verified,
+            sessionToken: response.sessionToken as Data, keyFetchToken: response.keyFetchToken as Data, unwrapkB: unwrapkB)
     }
 
-    private class func fromConfigurationAndParameters(configuration: FirefoxAccountConfiguration,
-            email: String, uid: String, deviceRegistration: FxADeviceRegistration?, verified: Bool,
-            sessionToken: NSData, keyFetchToken: NSData, unwrapkB: NSData) -> FirefoxAccount {
+    fileprivate class func from(configuration: FirefoxAccountConfiguration,
+            andParametersWithEmail email: String, uid: String, deviceRegistration: FxADeviceRegistration?, verified: Bool,
+            sessionToken: Data, keyFetchToken: Data, unwrapkB: Data) -> FirefoxAccount {
         var state: FxAState! = nil
         if !verified {
-            let now = NSDate.now()
+            let now = Date.now()
             state = EngagedBeforeVerifiedState(knownUnverifiedAt: now,
                 lastNotifiedUserAt: now,
                 sessionToken: sessionToken,
@@ -116,8 +117,8 @@ public class FirefoxAccount {
         return account
     }
 
-    public func asDictionary() -> [String: AnyObject] {
-        var dict: [String: AnyObject] = [:]
+    open func dictionary() -> [String: Any] {
+        var dict: [String: Any] = [:]
         dict["version"] = AccountSchemaVersion
         dict["email"] = email
         dict["uid"] = uid
@@ -127,7 +128,7 @@ public class FirefoxAccount {
         return dict
     }
 
-    public class func fromDictionary(dictionary: [String: AnyObject]) -> FirefoxAccount? {
+    open class func fromDictionary(_ dictionary: [String: Any]) -> FirefoxAccount? {
         if let version = dictionary["version"] as? Int {
             if version == AccountSchemaVersion {
                 return FirefoxAccount.fromDictionaryV1(dictionary)
@@ -136,17 +137,17 @@ public class FirefoxAccount {
         return nil
     }
 
-    private class func fromDictionaryV1(dictionary: [String: AnyObject]) -> FirefoxAccount? {
+    fileprivate class func fromDictionaryV1(_ dictionary: [String: Any]) -> FirefoxAccount? {
         var configurationLabel: FirefoxAccountConfigurationLabel? = nil
         if let rawValue = dictionary["configurationLabel"] as? String {
             configurationLabel = FirefoxAccountConfigurationLabel(rawValue: rawValue)
         }
         if let
             configurationLabel = configurationLabel,
-            email = dictionary["email"] as? String,
-            uid = dictionary["uid"] as? String {
+            let email = dictionary["email"] as? String,
+            let uid = dictionary["uid"] as? String {
                 let deviceRegistration = dictionary["deviceRegistration"] as? FxADeviceRegistration
-                let stateCache = KeychainCache.fromBranch("account.state", withLabel: dictionary["stateKeyLabel"] as? String, withDefault: SeparatedState(), factory: stateFromJSON)
+                let stateCache = KeychainCache.fromBranch("account.state", withLabel: dictionary["stateKeyLabel"] as? String, withDefault: SeparatedState(), factory: state)
                 return FirefoxAccount(
                     configuration: configurationLabel.toConfiguration(),
                     email: email, uid: uid,
@@ -157,16 +158,16 @@ public class FirefoxAccount {
     }
 
     public enum AccountError: MaybeErrorType {
-        case NotMarried
+        case notMarried
 
         public var description: String {
             switch self {
-            case NotMarried: return "Not married."
+            case .notMarried: return "Not married."
             }
         }
     }
 
-    public func advance() -> Deferred<FxAState> {
+    @discardableResult open func advance() -> Deferred<FxAState> {
         OSSpinLockLock(&advanceLock)
         if let deferred = advanceDeferred {
             // We already have an advance() in progress.  This consumer can chain from it.
@@ -179,10 +180,9 @@ public class FirefoxAccount {
         let cachedState = stateCache.value!
         var registration = succeed()
         if let session = cachedState as? TokenState {
-            registration = FxADeviceRegistrator.registerOrUpdateDevice(self, sessionToken: session.sessionToken).bind { result in
-                if result.successValue != FxADeviceRegistrationResult.AlreadyRegistered {
-                    let notification = NSNotification(name: NotificationFirefoxAccountDeviceRegistrationUpdated, object: nil)
-                    NSNotificationCenter.defaultCenter().postNotification(notification)
+            registration = FxADeviceRegistrator.registerOrUpdateDevice(self, sessionToken: session.sessionToken as NSData).bind { result in
+                if result.successValue != FxADeviceRegistrationResult.alreadyRegistered {
+                    NotificationCenter.default.post(name: NotificationFirefoxAccountDeviceRegistrationUpdated, object: nil)
                 }
                 return succeed()
             }
@@ -191,8 +191,8 @@ public class FirefoxAccount {
         let deferred: Deferred<FxAState> = registration.bind { _ in
             let client = FxAClient10(endpoint: self.configuration.authEndpointURL)
             let stateMachine = FxALoginStateMachine(client: client)
-            let now = NSDate.now()
-            return stateMachine.advanceFromState(cachedState, now: now).map { newState in
+            let now = Date.now()
+            return stateMachine.advance(fromState: cachedState, now: now).map { newState in
                 self.stateCache.value = newState
                 return newState
             }
@@ -205,7 +205,7 @@ public class FirefoxAccount {
         deferred.upon { _ in
             // This advance() is complete.  Clear the shared deferred.
             OSSpinLockLock(&self.advanceLock)
-            if let existingDeferred = self.advanceDeferred where existingDeferred === deferred {
+            if let existingDeferred = self.advanceDeferred, existingDeferred === deferred {
                 // The guard should not be needed, but should prevent trampling racing consumers.
                 self.advanceDeferred = nil
                 log.debug("advance() completed and shared deferred is existing deferred; clearing shared deferred.")
@@ -217,30 +217,30 @@ public class FirefoxAccount {
         return deferred
     }
 
-    public func marriedState() -> Deferred<Maybe<MarriedState>> {
+    open func marriedState() -> Deferred<Maybe<MarriedState>> {
         return advance().map { newState in
-            if newState.label == FxAStateLabel.Married {
+            if newState.label == FxAStateLabel.married {
                 if let married = newState as? MarriedState {
                     return Maybe(success: married)
                 }
             }
-            return Maybe(failure: AccountError.NotMarried)
+            return Maybe(failure: AccountError.notMarried)
         }
     }
 
-    public func makeSeparated() -> Bool {
+    @discardableResult open func makeSeparated() -> Bool {
         log.info("Making Account State be Separated.")
         self.stateCache.value = SeparatedState()
         return true
     }
 
-    public func makeDoghouse() -> Bool {
+    @discardableResult open func makeDoghouse() -> Bool {
         log.info("Making Account State be Doghouse.")
         self.stateCache.value = DoghouseState()
         return true
     }
 
-    public func makeCohabitingWithoutKeyPair() -> Bool {
+    open func makeCohabitingWithoutKeyPair() -> Bool {
         if let married = self.stateCache.value as? MarriedState {
             log.info("Making Account State be CohabitingWithoutKeyPair.")
             self.stateCache.value = married.withoutKeyPair()