Fix Swift Lint Warnings

Sources/ParseSwift/Objects Protocols/ObjectType.swift

@@ -51,8 +51,8 @@ internal extension ObjectType {
 extension ObjectType {
     // Parse ClassName inference
     public static var className: String {
-        let t = "\(type(of: self))"
-        return t.components(separatedBy: ".").first! // strip .Type
+        let classType = "\(type(of: self))"
+        return classType.components(separatedBy: ".").first! // strip .Type
     }
     public var className: String {
         return Self.className
@@ -120,7 +120,7 @@ let dateDecodingStrategy: JSONDecoder.DateDecodingStrategy = .custom({ (dec) ->
         let container = try dec.singleValueContainer()
         let decodedString = try container.decode(String.self)
         return dateFormatter.date(from: decodedString)!
-    } catch let e {
+    } catch let error {
         let container = try dec.container(keyedBy: DateEncodingKeys.self)
         if let decoded = try container.decodeIfPresent(String.self, forKey: .iso) {
             return dateFormatter.date(from: decoded)!
@@ -175,8 +175,8 @@ public extension ObjectType {
     public func fetch(options: API.Option, callback: @escaping ((Result<Self>) -> Void)) -> Cancellable? {
         do {
             return try fetchCommand().execute(options: options, callback)
-        } catch let e {
-            callback(.error(e))
+        } catch let error {
+            callback(.error(error))
         }
         return nil
     }

Sources/ParseSwift/REST/RESTBatchCommand.swift

@@ -55,20 +55,20 @@ struct SaveOrUpdateResponse: Decodable {
     }
 }
 
-public class RESTBatchCommand<T>: RESTBatchCommandType<T> where T: ObjectType {
+class RESTBatchCommand<T>: RESTBatchCommandType<T> where T: ObjectType {
     typealias ParseObjectCommand = RESTCommand<T, T>
     typealias ParseObjectBatchCommand = BatchCommand<T, T>
 
     init(commands: [ParseObjectCommand]) {
-        let commands = commands.flatMap { (command) -> RESTCommand<T, T>? in
+        let commands = commands.compactMap { (command) -> RESTCommand<T, T>? in
             let path = ParseConfiguration.mountPath + command.path.urlComponent
             guard let body = command.body else {
                 return nil
             }
             return RESTCommand<T, T>(method: command.method, path: .any(path),
                                      body: body, mapper: command.mapper)
         }
-        let bodies = commands.flatMap { (command) -> T? in
+        let bodies = commands.compactMap { (command) -> T? in
             return command.body
         }
         let mapper = { (data: Data) -> [(T, ParseError?)] in

Sources/ParseSwift/Result.swift

@@ -20,8 +20,8 @@ public enum Result<T> {
         case .success(let success):
             do {
                 return .success(try transform(success))
-            } catch let e {
-                return .error(e)
+            } catch let error {
+                return .error(error)
             }
         case .error(let error):
             return .error(error)
@@ -34,8 +34,8 @@ public enum Result<T> {
         case .success(let success):
             do {
                 return try transform(success)
-            } catch let e {
-                return .error(e)
+            } catch let error {
+                return .error(error)
             }
         case .error(let error):
             return .error(error)
@@ -56,11 +56,11 @@ extension Result where T == Data {
         case .success(let data):
             do {
                 return .success(try mapper(data))
-            } catch let e {
+            } catch let error {
                 do { // try default error mapper :)
                     return .error(try getDecoder().decode(ParseError.self, from: data))
                 } catch {}
-                return .error(e)
+                return .error(error)
             }
         case .error(let error):
             return .error(error)

Sources/ParseSwift/Synchronous.swift

@@ -12,13 +12,13 @@ typealias ResultCapturing<T> = (Result<T>) -> Void
 // Mark it private for now
 private func await<T>(block: (@escaping ResultCapturing<T>) -> Void) throws -> T {
     let sema = DispatchSemaphore(value: 0)
-    var r: Result<T>!
+    var result: Result<T>!
     block({
-        r = $0
+        result = $0
         sema.signal()
     })
     sema.wait()
-    switch r! {
+    switch result! {
     case .success(let value):
         return value
     case .error(let error):

Sources/ParseSwift/Types/ACL.swift

@@ -114,7 +114,7 @@ extension ACL {
                     try container.nestedContainer(keyedBy: Access.self, forKey: scope))
             }.flatMap { pair -> [(String, Access, Bool)] in
                 let (scope, accessValues) = pair
-                return try accessValues.allKeys.flatMap { (access) -> (String, Access, Bool)? in
+                return try accessValues.allKeys.compactMap { (access) -> (String, Access, Bool)? in
                     // swiftlint:disable line_length
                     guard let value = try accessValues.decodeIfPresent(Bool.self, forKey: access) else {
                     // swiftlint:enable line_length

Sources/ParseSwift/Types/Query.swift

@@ -112,10 +112,10 @@ internal struct QueryWhere: Encodable {
     public func encode(to encoder: Encoder) throws {
         var container = encoder.container(keyedBy: RawCodingKey.self)
         try _constraints.forEach { (key, value) in
-            var c = container.nestedContainer(keyedBy: QueryConstraint.Comparator.self,
+            var nestedContainer = container.nestedContainer(keyedBy: QueryConstraint.Comparator.self,
                                               forKey: .key(key))
             try value.forEach { (constraint) in
-                try constraint.encode(to: c.superEncoder(forKey: constraint.comparator))
+                try constraint.encode(to: nestedContainer.superEncoder(forKey: constraint.comparator))
             }
         }
     }