Clean up file attachments API (#63)

* Let the user specify their file attachments as simply a list of URLs

Author: rqbacktrace

Examples/Example-iOS/AppDelegate.swift

@@ -36,9 +36,12 @@ final class AppDelegate: UIResponder, UIApplicationDelegate {
         BacktraceClient.shared?.attributes = ["foo": "bar", "testing": true]
 
         let fileName = "sample.txt"
-        let fileUrl = try? createAndWriteFile(fileName)
+        guard let fileUrl = try? createAndWriteFile(fileName) else {
+            print("Could not create the file attachment")
+            return false
+        }
         var crashAttachments = Attachments()
-        crashAttachments[fileName] = fileUrl
+        crashAttachments.append(fileUrl)
         BacktraceClient.shared?.attachments = crashAttachments
 
         BacktraceClient.shared?.loggingDestinations = [BacktraceBaseDestination(level: .debug)]

Sources/Features/Attributes/AttributesProvider.swift

@@ -14,7 +14,7 @@ final class AttributesProvider {
 
     // attributes can be modified on runtime
     var attributes: Attributes = [:]
-    var attachments: Attachments = [:]
+    var attachments: Attachments = []
     private let attributesSources: [AttributesSource]
     private let faultInfo: FaultInfo
 
@@ -45,7 +45,7 @@ extension AttributesProvider: SignalContext {
     }
 
     var attachmentPaths: [String] {
-        return attachments.map(\.value.path)
+        return attachments.map(\.path)
     }
 
     var allAttributes: Attributes {

Sources/Features/Client/Model/AttachmentBookmarkHandler.swift

@@ -10,8 +10,8 @@ enum AttachmentBookmarkHandlerImpl: AttachmentBookmarkHandler {
         var attachmentsBookmarksDict = Bookmarks()
         for attachment in attachments {
             do {
-                let bookmark = try attachment.value.bookmarkData(options: URL.BookmarkCreationOptions.minimalBookmark)
-                attachmentsBookmarksDict[attachment.key] = bookmark
+                let bookmark = try attachment.bookmarkData(options: .minimalBookmark)
+                attachmentsBookmarksDict[attachment.path] = bookmark
             } catch {
                 BacktraceLogger.error("Could not bookmark attachment file URL. Error: \(error)")
                 continue
@@ -35,7 +35,7 @@ enum AttachmentBookmarkHandlerImpl: AttachmentBookmarkHandler {
                 BacktraceLogger.error("Bookmark data is stale. This should not happen")
                 continue
             }
-            attachments[bookmark.key] = fileUrl
+            attachments.append(fileUrl)
         }
         return attachments
     }

Sources/Public/BacktraceClientCustomizing.swift

@@ -7,8 +7,7 @@ public typealias BacktraceClientProtocol = BacktraceReporting & BacktraceClientC
 public typealias Attributes = [String: Any]
 
 /// Type-alias of passing file attachments to library.
-/// Expected format: Filename, File URL bookmark
-public typealias Attachments = [String: URL]
+public typealias Attachments = [URL]
 
 /// Type-alias of storing file attachments on disk (as a bookmark)
 /// Expected format: Filename, File URL bookmark

Sources/Public/BacktraceCrashReporter.swift

@@ -72,20 +72,21 @@ extension BacktraceCrashReporter: CrashReporting {
             BacktraceLogger.error("Could not get cache directory URL")
             return [URL]()
         }
-        let attachments = (try? AttachmentsStorage.retrieve(fileName: BacktraceCrashReporter.crashName)) ?? [:]
+        let attachments = (try? AttachmentsStorage.retrieve(fileName: BacktraceCrashReporter.crashName)) ?? []
         var copiedFileAttachments = [URL]()
         for attachment in attachments {
             let fileManager = FileManager.default
-            let copiedAttachmentPath = directoryUrl.appendingPathComponent(attachment.key)
+            let fileName = attachment.lastPathComponent
+            let copiedAttachmentPath = directoryUrl.appendingPathComponent(fileName)
             do {
-                if !fileManager.fileExists(atPath: attachment.value.path) {
+                if !fileManager.fileExists(atPath: attachment.path) {
                     BacktraceLogger.error("File attachment from previous session does not exist")
                     continue
                 }
                 if fileManager.fileExists(atPath: copiedAttachmentPath.path) {
                     try fileManager.removeItem(atPath: copiedAttachmentPath.path)
                 }
-                try fileManager.copyItem(at: attachment.value, to: copiedAttachmentPath)
+                try fileManager.copyItem(at: attachment, to: copiedAttachmentPath)
                 copiedFileAttachments.append(copiedAttachmentPath)
             } catch {
                 BacktraceLogger.error("Could not copy bookmarked attachment file from previous session. Error: \(error)")

Tests/AttachmentStorageTests.swift

@@ -16,7 +16,7 @@ final class AttachmentStorageTests: QuickSpec {
                 guard let fileUrl = try? self.createAFile() else {
                     throw FileError.fileNotWritten
                 }
-                crashAttachments["myFile"] = fileUrl
+                crashAttachments.append(fileUrl)
 
                 let attachmentsFileName = "attachments"
                 try? AttachmentsStorage.store(crashAttachments,
@@ -28,7 +28,7 @@ final class AttachmentStorageTests: QuickSpec {
                     (try? AttachmentsStorage.retrieve(fileName: attachmentsFileName,
                                                       storage: storage,
                                                       bookmarkHandler: bookmarkHandler)) ?? Attachments()
-                let attachmentPaths = attachments.map(\.value.path)
+                let attachmentPaths = attachments.map(\.path)
 
                 expect(attachmentPaths).toNot(beNil())
                 expect(attachmentPaths.count).to(be(1))
@@ -49,7 +49,7 @@ final class AttachmentStorageTests: QuickSpec {
                     (try? AttachmentsStorage.retrieve(fileName: attachmentsFileName,
                                                       storage: storage,
                                                       bookmarkHandler: bookmarkHandler)) ?? Attachments()
-                let attachmentPaths = attachments.map(\.value.path)
+                let attachmentPaths = attachments.map(\.path)
 
                 expect(attachmentPaths).toNot(beNil())
                 expect(attachmentPaths.count).to(be(0))

Tests/Mocks/AttachmentBookmarkHandlerMock.swift

@@ -2,19 +2,26 @@ import Foundation
 import XCTest
 @testable import Backtrace
 
+enum AttachmentsBookmarkError: Error {
+    case invalidUrl
+}
+
 enum AttachmentBookmarkHandlerMock: AttachmentBookmarkHandler {
     static func convertAttachmentUrlsToBookmarks(_ attachments: Attachments) throws -> Bookmarks {
         var attachmentsBookmarksDict = Bookmarks()
         for attachment in attachments {
-            attachmentsBookmarksDict[attachment.key] = attachment.value.path.data(using: .utf8)
+            attachmentsBookmarksDict[attachment.path] = attachment.path.data(using: .utf8)
         }
         return attachmentsBookmarksDict
     }
 
     static func extractAttachmentUrls(_ bookmarks: Bookmarks) throws -> Attachments {
         var attachments = Attachments()
         for bookmark in bookmarks {
-            attachments[bookmark.key] = URL(string: String(data: bookmark.value, encoding: .utf8) ?? String())
+            guard let fileUrl = URL(string: String(data: bookmark.value, encoding: .utf8) ?? String()) else {
+                throw AttachmentsBookmarkError.invalidUrl
+            }
+            attachments.append(fileUrl)
         }
         return attachments
     }