Merge pull request #278 from zapcannon87/developer

zapcannon87 · web-flow · commit be3845571102 · 2019-12-10T16:09:35.000+08:00
feat(storage): expressible by array literal of LCArray support LCValueConvertible
diff --git a/LeanCloudTests/LCEngineTestCase.swift b/LeanCloudTests/LCEngineTestCase.swift
@@ -11,12 +11,25 @@ import XCTest
 
 class LCEngineTestCase: BaseTestCase {
     
-    func testEngineFunction() {
-        XCTAssertEqual(LCEngine.run("test").value as? String, "test")
+    func testFunction() {
+        let result = LCEngine.run("test")
+        XCTAssertEqual(result.value as? String, "test")
+        XCTAssertNil(result.error)
     }
     
-    func testEngineRPC() {
-        XCTAssertTrue(LCEngine.call("test").isSuccess)
+    func testError() {
+        let result = LCEngine.run("error")
+        XCTAssertNil(result.value)
+        XCTAssertNotNil(LCEngine.run("error").error)
+    }
+    
+    func testGetOnOffStatus() {
+        let result = LCEngine.run(
+            "getOnOffStatus",
+            parameters: ["peerIds":
+                ["FCA6CAA7E5A14748BA25DE46EC1B66C8",
+                 UUID().uuidString]])
+        XCTAssertEqual((result.value as? [Any])?.count, 2)
+        XCTAssertNil(result.error)
     }
-
 }
diff --git a/LeanCloudTests/LCTypeTestCase.swift b/LeanCloudTests/LCTypeTestCase.swift
@@ -65,6 +65,14 @@ class LCTypeTestCase: BaseTestCase {
             LCArray([42, true, NSNull(), [String: String](), [String](), Data(), date, object]),
             try LCArray(unsafeObject: [42, true, NSNull(), [String: String](), [String](), Data(), date, object]))
     }
+    
+    func testArrayLiteral() {
+        let _: LCArray = ["a"]
+        let _: LCArray = ["a", 1]
+        let _: LCArray = ["a", LCNumber(1)]
+        let _: LCArray = [LCString("a"), 1]
+        let _: LCArray = [LCString("a"), LCNumber(1)]
+    }
 
     func testDictionaryConvertible() {
         let date = Date()
diff --git a/Sources/Foundation/Array.swift b/Sources/Foundation/Array.swift
@@ -8,12 +8,8 @@
 
 import Foundation
 
-/**
- LeanCloud list type.
-
- It is a wrapper of `Swift.Array` type, used to store a list of objects.
- */
-public final class LCArray: NSObject, LCValue, LCValueExtension, Collection, ExpressibleByArrayLiteral {
+/// LeanCloud List Type
+public class LCArray: NSObject, LCValue, Collection, ExpressibleByArrayLiteral {
     public typealias Index = Int
     public typealias Element = LCValue
 
@@ -30,137 +26,148 @@ public final class LCArray: NSObject, LCValue, LCValueExtension, Collection, Exp
 
     public convenience init(_ value: [LCValueConvertible]) {
         self.init()
-        self.value = value.map { element in element.lcValue }
+        self.value = value.map { $0.lcValue }
     }
 
-    public convenience required init(arrayLiteral elements: Element...) {
+    public convenience required init(arrayLiteral elements: LCValueConvertible...) {
         self.init(elements)
     }
 
     public convenience init(
-        application: LCApplication = LCApplication.default,
+        application: LCApplication = .default,
         unsafeObject: Any)
         throws
     {
         self.init()
-
         guard let object = unsafeObject as? [Any] else {
             throw LCError(
                 code: .malformedData,
-                reason: "Failed to construct LCArray with non-array object.")
+                reason: "Failed to construct \(LCArray.self) with a \(type(of: unsafeObject)) object.")
         }
-
-        value = try object.map { element in
+        self.value = try object.map { element in
             try ObjectProfiler.shared.object(application: application, jsonValue: element)
         }
     }
 
     public required init?(coder aDecoder: NSCoder) {
-        value = (aDecoder.decodeObject(forKey: "value") as? [Element]) ?? []
+        self.value = (aDecoder.decodeObject(forKey: "value") as? [Element]) ?? []
     }
 
     public func encode(with aCoder: NSCoder) {
-        aCoder.encode(value, forKey: "value")
+        aCoder.encode(self.value, forKey: "value")
     }
 
     public func copy(with zone: NSZone?) -> Any {
-        return LCArray(value)
+        return LCArray(self.value)
     }
 
     public override func isEqual(_ object: Any?) -> Bool {
         if let object = object as? LCArray {
-            return object === self || object.value == value
+            return object === self || object.value == self.value
         } else {
             return false
         }
     }
 
     public func makeIterator() -> IndexingIterator<[Element]> {
-        return value.makeIterator()
+        return self.value.makeIterator()
     }
 
     public var startIndex: Int {
         return 0
     }
 
     public var endIndex: Int {
-        return value.count
+        return self.value.count
     }
 
     public func index(after i: Int) -> Int {
-        return value.index(after: i)
+        return self.value.index(after: i)
     }
 
     public subscript(index: Int) -> LCValue {
-        get { return value[index] }
+        get {
+            return self.value[index]
+        }
     }
 
     public var jsonValue: Any {
-        return value.map { element in element.jsonValue }
-    }
-
-    func formattedJSONString(indentLevel: Int, numberOfSpacesForOneIndentLevel: Int = 4) -> String {
-        if value.isEmpty {
-            return "[]"
-        }
-
-        let lastIndent = " " * (numberOfSpacesForOneIndentLevel * indentLevel)
-        let bodyIndent = " " * (numberOfSpacesForOneIndentLevel * (indentLevel + 1))
-        let body = value
-            .map { value in (value as! LCValueExtension).formattedJSONString(indentLevel: indentLevel + 1, numberOfSpacesForOneIndentLevel: numberOfSpacesForOneIndentLevel) }
-            .joined(separator: ",\n" + bodyIndent)
-
-        return "[\n\(bodyIndent)\(body)\n\(lastIndent)]"
+        return self.value.map { $0.jsonValue }
     }
 
     public var jsonString: String {
-        return formattedJSONString(indentLevel: 0)
+        return self.formattedJSONString(indentLevel: 0)
     }
 
     public var rawValue: Any {
-        let v: [Any] = self.value.map { element in element.rawValue }
-        return v
+        return self.value.map { $0.rawValue }
     }
+}
 
+extension LCArray: LCValueExtension {
+    
     var lconValue: Any? {
-        return value.compactMap { element in (element as? LCValueExtension)?.lconValue }
+        return self.value.compactMap { ($0 as? LCValueExtension)?.lconValue }
     }
     
     static func instance(application: LCApplication) -> LCValue {
-        return self.init([])
+        return self.init()
     }
-
+    
     func forEachChild(_ body: (_ child: LCValue) throws -> Void) rethrows {
-        try forEach { element in try body(element) }
+        try forEach { try body($0) }
     }
-
+    
     func add(_ other: LCValue) throws -> LCValue {
-        throw LCError(code: .invalidType, reason: "Object cannot be added.")
+        throw LCError(
+            code: .invalidType,
+            reason: "\(LCArray.self) cannot do `add(_:)`.")
     }
-
+    
     func concatenate(_ other: LCValue, unique: Bool) throws -> LCValue {
-        let result   = LCArray(value)
-        let elements = (other as! LCArray).value
-
+        guard let elements = (other as? LCArray)?.value else {
+            throw LCError(
+                code: .invalidType,
+                reason: "\(LCArray.self) cannot do `concatenate(_:unique:)` with a \(type(of: other)) object.")
+        }
+        let result = LCArray(self.value)
         result.concatenateInPlace(elements, unique: unique)
-
         return result
     }
-
+    
     func concatenateInPlace(_ elements: [Element], unique: Bool) {
-        value = unique ? (value +~ elements) : (value + elements)
+        self.value = unique
+            ? (self.value +~ elements)
+            : (self.value + elements)
     }
-
+    
     func differ(_ other: LCValue) throws -> LCValue {
-        let result   = LCArray(value)
-        let elements = (other as! LCArray).value
-
+        guard let elements = (other as? LCArray)?.value else {
+            throw LCError(
+                code: .invalidType,
+                reason: "\(LCArray.self) cannot do `differ(_:)` with a \(type(of: other)) object.")
+        }
+        let result = LCArray(self.value)
         result.differInPlace(elements)
-
         return result
     }
-
+    
     func differInPlace(_ elements: [Element]) {
-        value = value - elements
+        self.value = (self.value - elements)
+    }
+    
+    func formattedJSONString(indentLevel: Int, numberOfSpacesForOneIndentLevel: Int = 4) -> String {
+        if self.value.isEmpty {
+            return "[]"
+        }
+        let lastIndent = " " * (numberOfSpacesForOneIndentLevel * indentLevel)
+        let bodyIndent = " " * (numberOfSpacesForOneIndentLevel * (indentLevel + 1))
+        let body = self.value
+            .compactMap {
+                ($0 as? LCValueExtension)?.formattedJSONString(
+                    indentLevel: indentLevel + 1,
+                    numberOfSpacesForOneIndentLevel: numberOfSpacesForOneIndentLevel) }
+            .joined(separator: ",\n" + bodyIndent)
+        return "[\n\(bodyIndent)\(body)\n\(lastIndent)]"
     }
 }
diff --git a/Sources/Foundation/Extension.swift b/Sources/Foundation/Extension.swift
@@ -108,6 +108,7 @@ func ==(lhs: [LCDictionary.Key: LCDictionary.Value], rhs: [LCDictionary.Key: LCD
 }
 
 extension Dictionary {
+    
     init(elements: [Element]) {
         self.init()
 
@@ -133,47 +134,20 @@ extension Dictionary {
         return Dictionary<Key, T>(elements: elements)
     }
     
-    /*
-     Maybe you will think: Why use JSONSerialization encoding and decoding `Dictionary` ?
-     
-     Because a Swift Raw Data Type `[String: Any]` is Strong-Type-Checking.
-     
-     e.g.
-     ```
-     var dic: [String: Any] = ["foo": Int32(1)]
-     (dic["foo"] as? Int) == nil
-     (dic["foo"] as? Int32) == Optional(1)
-     ```
-     
-     But after JSONSerialization's encoding and decoding.
-     
-     The Swift Type `[String: Any]` has been converted to a Real JSON Object.
-     
-     ```
-     dic = try! dic.jsonObject()
-     (dic["foo"] as? Int) == Optional(1)
-     (dic["foo"] as? Int32) == Optional(1)
-     ```
-     
-     This will make data better for SDK to handle it.
-     */
     func jsonObject() throws -> [Key: Value]? {
-        let data: Data = try JSONSerialization.data(withJSONObject: self)
-        if let json: [Key: Value] = try JSONSerialization.jsonObject(with: data) as? [Key: Value] {
-            return json
-        } else {
-            return nil
-        }
+        return try JSONSerialization.jsonObject(with:
+            try JSONSerialization.data(withJSONObject: self))
+            as? [Key: Value]
     }
     
     func jsonString(
         using encoding: String.Encoding = .utf8,
         options: JSONSerialization.WritingOptions = [])
-        throws
-        -> String?
+        throws -> String?
     {
-        let data: Data = try JSONSerialization.data(withJSONObject: self, options: options)
-        return String(data: data, encoding: encoding)
+        return String(
+            data: try JSONSerialization.data(withJSONObject: self, options: options),
+            encoding: encoding)
     }
 }
 
@@ -222,17 +196,13 @@ extension String {
     func jsonObject<T>(
         using encoding: String.Encoding = .utf8,
         options: JSONSerialization.ReadingOptions = [])
-        throws
-        -> T?
+        throws -> T?
     {
-        guard !self.isEmpty else {
-            return nil
-        }
-        if let data: Data = self.data(using: encoding) {
-            return try JSONSerialization.jsonObject(with: data, options: options) as? T
-        } else {
-            return nil
+        guard !self.isEmpty,
+            let data = self.data(using: encoding) else {
+                return nil
         }
+        return try JSONSerialization.jsonObject(with: data, options: options) as? T
     }
 }
 
@@ -245,11 +215,11 @@ extension Sequence {
     func jsonString(
         using encoding: String.Encoding = .utf8,
         options: JSONSerialization.WritingOptions = [])
-        throws
-        -> String?
+        throws -> String?
     {
-        let data: Data = try JSONSerialization.data(withJSONObject: self, options: options)
-        return String(data: data, encoding: encoding)
+        return String(
+            data: try JSONSerialization.data(withJSONObject: self, options: options),
+            encoding: encoding)
     }
 }
 
@@ -303,7 +273,6 @@ extension LCError {
             self = LCError(error: error)
         }
     }
-
 }
 
 /**
