Merge pull request #7 from blocto/feat/capacity-decoding

Feat - update for Cadence decoding

Author: yuhsuan19

Sources/Cadence/Argument.swift

@@ -315,8 +315,8 @@ extension Argument {
         Argument(.capability(value))
     }
 
-    public static func capability(path: String, address: Address, borrowType: FType) -> Argument {
-        Argument(.capability(Capability(path: path, address: address, borrowType: borrowType)))
+    public static func capability(id: String, address: Address, borrowType: FType) -> Argument {
+        Argument(.capability(Capability(id: id, address: address, borrowType: borrowType)))
     }
 
 }

Sources/Cadence/CType/IntersectionType.swift

@@ -0,0 +1,24 @@
+//
+//  File.swift
+//  
+//
+//  Created by Shane Chi on 2024/9/30.
+//
+
+import Foundation
+
+public struct IntersectionType: Equatable, Codable {
+    public let typeId: String
+    public let types: [FType]
+
+    public init(typeId: String, types: [FType]) {
+        self.typeId = typeId
+        self.types = types
+    }
+
+    // MARK: Codable
+    enum CodingKeys: String, CodingKey {
+        case typeId = "typeID"
+        case types
+    }
+}

Sources/Cadence/Capability.swift

@@ -10,16 +10,16 @@ import Foundation
 /// https://docs.onflow.org/cadence/json-cadence-spec/#capability
 public struct Capability: Codable, Equatable {
 
-    public let path: String
+    public let id: String
     public let address: Address
     public let borrowType: FType
 
     public init(
-        path: String,
+        id: String,
         address: Address,
         borrowType: FType
     ) {
-        self.path = path
+        self.id = id
         self.address = address
         self.borrowType = borrowType
     }

Sources/Cadence/FType.swift

@@ -75,6 +75,7 @@ public enum FType: Equatable {
     indirect case restriction(RestrictionType)
     indirect case capability(borrowType: FType)
     indirect case `enum`(EnumType)
+    indirect case intersection(IntersectionType)
 
     public var kind: FTypeKind {
         switch self {
@@ -212,6 +213,8 @@ public enum FType: Equatable {
             return .capability
         case .enum:
             return .enum
+        case .intersection:
+            return .intersection
         }
     }
 
@@ -263,6 +266,8 @@ public enum FType: Equatable {
             return "\(kind.rawValue)<\(borrowType.id)>"
         case let .enum(enumType):
             return enumType.typeId
+        case let .intersection(IntersectionType):
+            return IntersectionType.typeId
         }
     }
 }
@@ -468,6 +473,8 @@ extension FType: Codable {
             self = .enum(enumType)
             decoder.addTypeToDecodingResultsIfPossible(type: self, typeId: enumType.typeId)
             try enumType.decodePossibleRepeatedProperties(from: decoder)
+        case .intersection:
+            self = .intersection(try IntersectionType(from: decoder))
         }
     }
 

Sources/Cadence/FTypeKind.swift

@@ -75,4 +75,5 @@ public enum FTypeKind: String, Equatable, Codable {
     case restriction = "Restriction"
     case capability = "Capability"
     case `enum` = "Enum"
+    case intersection = "Intersection"
 }

Sources/Cadence/Format.swift

@@ -39,7 +39,7 @@ enum Format {
     case capability(
         borrowType: FType,
         address: Address,
-        path: String)
+        id: String)
 }
 
 // MARK: - CustomStringConvertible
@@ -131,9 +131,9 @@ extension Format: CustomStringConvertible {
             } else {
                 return "Type<\(type.id)>()"
             }
-        case let .capability(borrowType, address, path):
+        case let .capability(borrowType, address, id):
             let typeArgument = borrowType.id.isEmpty ? "" : "<\(borrowType.id)>"
-            return "Capability\(typeArgument)(address: \(address.hexStringWithPrefix), path: \(path))"
+            return "Capability\(typeArgument)(address: \(address.hexStringWithPrefix), id: \(id))"
         }
     }
 

Sources/Cadence/Value.swift

@@ -508,7 +508,7 @@ extension Value: CustomStringConvertible {
             return Format.capability(
                 borrowType: capability.borrowType,
                 address: capability.address,
-                path: capability.path
+                id: capability.id
             ).description
         }
     }

Tests/CadenceTests/ArgumentTests.swift

@@ -749,7 +749,7 @@ final class ArgumentTests: XCTestCase {
         {
           "type": "Capability",
           "value": {
-            "path": "/public/someInteger",
+            "id": "7",
             "address": "0x1",
             "borrowType": {
               "kind": "Int"
@@ -765,7 +765,7 @@ final class ArgumentTests: XCTestCase {
         XCTAssertEqual(argument.type, .capability)
         XCTAssertEqual(argument.value, .capability(
             .init(
-                path: "/public/someInteger",
+                id: "7",
                 address: Address(hexString: "0x1"),
                 borrowType: .int
             )

Tests/CadenceTests/StaticTypeTests.swift

@@ -1394,6 +1394,26 @@ final class StaticTypeTests: XCTestCase {
         XCTAssertEqual(value.kind, .reference)
     }
 
+    func testDecodeIntersectionType() throws {
+        // Given:
+        let jsonData = """
+        {
+          "kind": "Intersection",
+          "typeID": "type-id",
+          "types": [{
+            "kind": "String"
+          }]
+        }
+        """.data(using: .utf8)!
+
+        // When:
+        let value = try decoder.decode(FType.self, from: jsonData)
+
+        // Then
+        XCTAssertEqual(value, .intersection(.init(typeId: "type-id", types: [.string])))
+        XCTAssertEqual(value.kind, .intersection)
+    }
+
     func testDecodeRestrictedType() throws {
         // Given:
         let jsonData = """

Tests/CadenceTests/ValueTests.swift

@@ -564,7 +564,7 @@ final class ValueTests: XCTestCase {
     func testToSwiftValueCapability() throws {
         // Arrange
         let capability = Capability(
-            path: "path",
+            id: "id",
             address: Address(hexString: "0xcb2d04fc89307107"),
             borrowType: .fix64)
         let value: Cadence.Value = .capability(capability)
@@ -651,10 +651,10 @@ final class ValueTests: XCTestCase {
         ).description, "Type<Int>()")
         XCTAssertEqual(Value.capability(
             .init(
-                path: "/storage/foo",
+                id: "id",
                 address: Address(data: Data([1, 2, 3, 4, 5])),
                 borrowType: .int)
-        ).description, "Capability<Int>(address: 0x0000000102030405, path: /storage/foo)")
+        ).description, "Capability<Int>(address: 0x0000000102030405, id: id)")
     }
 
     func testToSwiftValueDecodable() throws {