Swift-format FileProviderExt

.swift-format.json

@@ -0,0 +1,69 @@
+{
+  "fileScopedDeclarationPrivacy" : {
+    "accessLevel" : "private"
+  },
+  "indentation" : {
+    "spaces" : 4
+  },
+  "indentConditionalCompilationBlocks" : true,
+  "indentSwitchCaseLabels" : false,
+  "lineBreakAroundMultilineExpressionChainComponents" : false,
+  "lineBreakBeforeControlFlowKeywords" : false,
+  "lineBreakBeforeEachArgument" : false,
+  "lineBreakBeforeEachGenericRequirement" : false,
+  "lineLength" : 100,
+  "maximumBlankLines" : 1,
+  "multiElementCollectionTrailingCommas" : true,
+  "noAssignmentInExpressions" : {
+    "allowedFunctions" : [
+      "XCTAssertNoThrow"
+    ]
+  },
+  "prioritizeKeepingFunctionOutputTogether" : false,
+  "respectsExistingLineBreaks" : true,
+  "rules" : {
+    "AllPublicDeclarationsHaveDocumentation" : false,
+    "AlwaysUseLiteralForEmptyCollectionInit" : false,
+    "AlwaysUseLowerCamelCase" : true,
+    "AmbiguousTrailingClosureOverload" : true,
+    "BeginDocumentationCommentWithOneLineSummary" : false,
+    "DoNotUseSemicolons" : true,
+    "DontRepeatTypeInStaticProperties" : true,
+    "FileScopedDeclarationPrivacy" : true,
+    "FullyIndirectEnum" : true,
+    "GroupNumericLiterals" : true,
+    "IdentifiersMustBeASCII" : true,
+    "NeverForceUnwrap" : false,
+    "NeverUseForceTry" : false,
+    "NeverUseImplicitlyUnwrappedOptionals" : false,
+    "NoAccessLevelOnExtensionDeclaration" : true,
+    "NoAssignmentInExpressions" : true,
+    "NoBlockComments" : true,
+    "NoCasesWithOnlyFallthrough" : true,
+    "NoEmptyTrailingClosureParentheses" : true,
+    "NoLabelsInCasePatterns" : true,
+    "NoLeadingUnderscores" : false,
+    "NoParensAroundConditions" : true,
+    "NoPlaygroundLiterals" : true,
+    "NoVoidReturnOnFunctionSignature" : true,
+    "OmitExplicitReturns" : false,
+    "OneCasePerLine" : true,
+    "OneVariableDeclarationPerLine" : true,
+    "OnlyOneTrailingClosureArgument" : true,
+    "OrderedImports" : true,
+    "ReplaceForEachWithForLoop" : true,
+    "ReturnVoidInsteadOfEmptyTuple" : true,
+    "TypeNamesShouldBeCapitalized" : true,
+    "UseEarlyExits" : false,
+    "UseLetInEveryBoundCaseVariable" : true,
+    "UseShorthandTypeNames" : true,
+    "UseSingleLinePropertyGetter" : true,
+    "UseSynthesizedInitializer" : true,
+    "UseTripleSlashForDocumentationComments" : true,
+    "UseWhereClausesInForLoops" : false,
+    "ValidateDocumentationComments" : false
+  },
+  "spacesAroundRangeFormationOperators" : false,
+  "tabWidth" : 8,
+  "version" : 1
+}

shell_integration/MacOSX/NextcloudIntegration/FileProviderExt/Database/NextcloudFilesDatabaseManager+Directories.swift

@@ -20,57 +20,85 @@ extension NextcloudFilesDatabaseManager {
         // We want to split by "/" (e.g. cloud.nc.com/files/a/b) but we need to be mindful of "https://c.nc.com"
         let problematicSeparator = "://"
         let placeholderSeparator = "__TEMP_REPLACE__"
-        let serverUrlWithoutPrefix = serverUrl.replacingOccurrences(of: problematicSeparator, with: placeholderSeparator)
+        let serverUrlWithoutPrefix = serverUrl.replacingOccurrences(
+            of: problematicSeparator, with: placeholderSeparator)
         var splitServerUrl = serverUrlWithoutPrefix.split(separator: "/")
         let directoryItemFileName = String(splitServerUrl.removeLast())
-        let directoryItemServerUrl = splitServerUrl.joined(separator: "/").replacingOccurrences(of: placeholderSeparator, with: problematicSeparator)
-
-        if let metadata = ncDatabase().objects(NextcloudItemMetadataTable.self).filter("account == %@ AND serverUrl == %@ AND fileName == %@ AND directory == true", account, directoryItemServerUrl, directoryItemFileName).first {
+        let directoryItemServerUrl = splitServerUrl.joined(separator: "/").replacingOccurrences(
+            of: placeholderSeparator, with: problematicSeparator)
+
+        if let metadata = ncDatabase().objects(NextcloudItemMetadataTable.self).filter(
+            "account == %@ AND serverUrl == %@ AND fileName == %@ AND directory == true", 
+            account,
+            directoryItemServerUrl, 
+            directoryItemFileName
+        ).first {
             return NextcloudItemMetadataTable(value: metadata)
         }
 
         return nil
     }
 
-    func childItemsForDirectory(_ directoryMetadata: NextcloudItemMetadataTable) -> [NextcloudItemMetadataTable] {
+    func childItemsForDirectory(_ directoryMetadata: NextcloudItemMetadataTable)
+        -> [NextcloudItemMetadataTable]
+    {
         let directoryServerUrl = directoryMetadata.serverUrl + "/" + directoryMetadata.fileName
-        let metadatas = ncDatabase().objects(NextcloudItemMetadataTable.self).filter("serverUrl BEGINSWITH %@", directoryServerUrl)
+        let metadatas = ncDatabase().objects(NextcloudItemMetadataTable.self).filter(
+            "serverUrl BEGINSWITH %@", directoryServerUrl)
         return sortedItemMetadatas(metadatas)
     }
 
-    func childDirectoriesForDirectory(_ directoryMetadata: NextcloudItemMetadataTable) -> [NextcloudItemMetadataTable] {
+    func childDirectoriesForDirectory(_ directoryMetadata: NextcloudItemMetadataTable)
+        -> [NextcloudItemMetadataTable]
+    {
         let directoryServerUrl = directoryMetadata.serverUrl + "/" + directoryMetadata.fileName
-        let metadatas = ncDatabase().objects(NextcloudItemMetadataTable.self).filter("serverUrl BEGINSWITH %@ AND directory == true", directoryServerUrl)
+        let metadatas = ncDatabase().objects(NextcloudItemMetadataTable.self).filter(
+            "serverUrl BEGINSWITH %@ AND directory == true", directoryServerUrl)
         return sortedItemMetadatas(metadatas)
     }
 
-    func parentDirectoryMetadataForItem(_ itemMetadata: NextcloudItemMetadataTable) -> NextcloudItemMetadataTable? {
-        return directoryMetadata(account: itemMetadata.account, serverUrl: itemMetadata.serverUrl)
+    func parentDirectoryMetadataForItem(_ itemMetadata: NextcloudItemMetadataTable)
+        -> NextcloudItemMetadataTable?
+    {
+        directoryMetadata(account: itemMetadata.account, serverUrl: itemMetadata.serverUrl)
     }
 
     func directoryMetadata(ocId: String) -> NextcloudItemMetadataTable? {
-        if let metadata = ncDatabase().objects(NextcloudItemMetadataTable.self).filter("ocId == %@ AND directory == true", ocId).first {
+        if let metadata = ncDatabase().objects(NextcloudItemMetadataTable.self).filter(
+            "ocId == %@ AND directory == true", ocId
+        ).first {
             return NextcloudItemMetadataTable(value: metadata)
         }
 
         return nil
     }
 
     func directoryMetadatas(account: String) -> [NextcloudItemMetadataTable] {
-        let metadatas = ncDatabase().objects(NextcloudItemMetadataTable.self).filter("account == %@ AND directory == true", account)
+        let metadatas = ncDatabase().objects(NextcloudItemMetadataTable.self).filter(
+            "account == %@ AND directory == true", account)
         return sortedItemMetadatas(metadatas)
     }
 
-    func directoryMetadatas(account: String, parentDirectoryServerUrl: String) -> [NextcloudItemMetadataTable] {
-        let metadatas = ncDatabase().objects(NextcloudItemMetadataTable.self).filter("account == %@ AND parentDirectoryServerUrl == %@ AND directory == true", account, parentDirectoryServerUrl)
+    func directoryMetadatas(account: String, parentDirectoryServerUrl: String)
+        -> [NextcloudItemMetadataTable]
+    {
+        let metadatas = ncDatabase().objects(NextcloudItemMetadataTable.self).filter(
+            "account == %@ AND parentDirectoryServerUrl == %@ AND directory == true", account,
+            parentDirectoryServerUrl)
         return sortedItemMetadatas(metadatas)
     }
 
     // Deletes all metadatas related to the info of the directory provided
     func deleteDirectoryAndSubdirectoriesMetadata(ocId: String) -> [NextcloudItemMetadataTable]? {
         let database = ncDatabase()
-        guard let directoryMetadata = database.objects(NextcloudItemMetadataTable.self).filter("ocId == %@ AND directory == true", ocId).first else {
-            Logger.ncFilesDatabase.error("Could not find directory metadata for ocId \(ocId, privacy: .public). Not proceeding with deletion")
+        guard
+            let directoryMetadata = database.objects(NextcloudItemMetadataTable.self).filter(
+                "ocId == %@ AND directory == true", ocId
+            ).first
+        else {
+            Logger.ncFilesDatabase.error(
+                "Could not find directory metadata for ocId \(ocId, privacy: .public). Not proceeding with deletion"
+            )
             return nil
         }
 
@@ -79,20 +107,25 @@ extension NextcloudFilesDatabaseManager {
         let directoryAccount = directoryMetadata.account
         let directoryEtag = directoryMetadata.etag
 
-        Logger.ncFilesDatabase.debug("Deleting root directory metadata in recursive delete. ocID: \(directoryMetadata.ocId, privacy: .public), etag: \(directoryEtag, privacy: .public), serverUrl: \(directoryUrlPath, privacy: .public)")
+        Logger.ncFilesDatabase.debug(
+            "Deleting root directory metadata in recursive delete. ocID: \(directoryMetadata.ocId, privacy: .public), etag: \(directoryEtag, privacy: .public), serverUrl: \(directoryUrlPath, privacy: .public)"
+        )
 
         guard deleteItemMetadata(ocId: directoryMetadata.ocId) else {
-            Logger.ncFilesDatabase.debug("Failure to delete root directory metadata in recursive delete. ocID: \(directoryMetadata.ocId, privacy: .public), etag: \(directoryEtag, privacy: .public), serverUrl: \(directoryUrlPath, privacy: .public)")
+            Logger.ncFilesDatabase.debug(
+                "Failure to delete root directory metadata in recursive delete. ocID: \(directoryMetadata.ocId, privacy: .public), etag: \(directoryEtag, privacy: .public), serverUrl: \(directoryUrlPath, privacy: .public)"
+            )
             return nil
         }
 
         var deletedMetadatas: [NextcloudItemMetadataTable] = [directoryMetadataCopy]
 
-        let results = database.objects(NextcloudItemMetadataTable.self).filter("account == %@ AND serverUrl BEGINSWITH %@", directoryAccount, directoryUrlPath)
+        let results = database.objects(NextcloudItemMetadataTable.self).filter(
+            "account == %@ AND serverUrl BEGINSWITH %@", directoryAccount, directoryUrlPath)
 
         for result in results {
             let successfulItemMetadataDelete = deleteItemMetadata(ocId: result.ocId)
-            if (successfulItemMetadataDelete) {
+            if successfulItemMetadataDelete {
                 deletedMetadatas.append(NextcloudItemMetadataTable(value: result))
             }
 
@@ -101,24 +134,35 @@ extension NextcloudFilesDatabaseManager {
             }
         }
 
-        Logger.ncFilesDatabase.debug("Completed deletions in directory recursive delete. ocID: \(directoryMetadata.ocId, privacy: .public), etag: \(directoryEtag, privacy: .public), serverUrl: \(directoryUrlPath, privacy: .public)")
+        Logger.ncFilesDatabase.debug(
+            "Completed deletions in directory recursive delete. ocID: \(directoryMetadata.ocId, privacy: .public), etag: \(directoryEtag, privacy: .public), serverUrl: \(directoryUrlPath, privacy: .public)"
+        )
 
         return deletedMetadatas
     }
 
-    func renameDirectoryAndPropagateToChildren(ocId: String, newServerUrl: String, newFileName: String) -> [NextcloudItemMetadataTable]? {
-
+    func renameDirectoryAndPropagateToChildren(
+        ocId: String, newServerUrl: String, newFileName: String
+    ) -> [NextcloudItemMetadataTable]? {
         let database = ncDatabase()
 
-        guard let directoryMetadata = database.objects(NextcloudItemMetadataTable.self).filter("ocId == %@ AND directory == true", ocId).first else {
-            Logger.ncFilesDatabase.error("Could not find a directory with ocID \(ocId, privacy: .public), cannot proceed with recursive renaming")
+        guard
+            let directoryMetadata = database.objects(NextcloudItemMetadataTable.self).filter(
+                "ocId == %@ AND directory == true", ocId
+            ).first
+        else {
+            Logger.ncFilesDatabase.error(
+                "Could not find a directory with ocID \(ocId, privacy: .public), cannot proceed with recursive renaming"
+            )
             return nil
         }
 
         let oldItemServerUrl = directoryMetadata.serverUrl
         let oldDirectoryServerUrl = oldItemServerUrl + "/" + directoryMetadata.fileName
         let newDirectoryServerUrl = newServerUrl + "/" + newFileName
-        let childItemResults = database.objects(NextcloudItemMetadataTable.self).filter("account == %@ AND serverUrl BEGINSWITH %@", directoryMetadata.account, oldDirectoryServerUrl)
+        let childItemResults = database.objects(NextcloudItemMetadataTable.self).filter(
+            "account == %@ AND serverUrl BEGINSWITH %@", directoryMetadata.account,
+            oldDirectoryServerUrl)
 
         renameItemMetadata(ocId: ocId, newServerUrl: newServerUrl, newFileName: newFileName)
         Logger.ncFilesDatabase.debug("Renamed root renaming directory")
@@ -127,19 +171,25 @@ extension NextcloudFilesDatabaseManager {
             try database.write {
                 for childItem in childItemResults {
                     let oldServerUrl = childItem.serverUrl
-                    let movedServerUrl = oldServerUrl.replacingOccurrences(of: oldDirectoryServerUrl, with: newDirectoryServerUrl)
+                    let movedServerUrl = oldServerUrl.replacingOccurrences(
+                        of: oldDirectoryServerUrl, with: newDirectoryServerUrl)
                     childItem.serverUrl = movedServerUrl
                     database.add(childItem, update: .all)
-                    Logger.ncFilesDatabase.debug("Moved childItem at \(oldServerUrl) to \(movedServerUrl)")
+                    Logger.ncFilesDatabase.debug(
+                        "Moved childItem at \(oldServerUrl) to \(movedServerUrl)")
                 }
             }
-        } catch let error {
-            Logger.ncFilesDatabase.error("Could not rename directory metadata with ocId: \(ocId, privacy: .public) to new serverUrl: \(newServerUrl), received error: \(error.localizedDescription, privacy: .public)")
+        } catch {
+            Logger.ncFilesDatabase.error(
+                "Could not rename directory metadata with ocId: \(ocId, privacy: .public) to new serverUrl: \(newServerUrl), received error: \(error.localizedDescription, privacy: .public)"
+            )
 
             return nil
         }
 
-        let updatedChildItemResults = database.objects(NextcloudItemMetadataTable.self).filter("account == %@ AND serverUrl BEGINSWITH %@", directoryMetadata.account, newDirectoryServerUrl)
+        let updatedChildItemResults = database.objects(NextcloudItemMetadataTable.self).filter(
+            "account == %@ AND serverUrl BEGINSWITH %@", directoryMetadata.account,
+            newDirectoryServerUrl)
         return sortedItemMetadatas(updatedChildItemResults)
     }
 }

shell_integration/MacOSX/NextcloudIntegration/FileProviderExt/Database/NextcloudFilesDatabaseManager+LocalFiles.swift

@@ -13,12 +13,14 @@
  */
 
 import Foundation
-import RealmSwift
 import OSLog
+import RealmSwift
 
 extension NextcloudFilesDatabaseManager {
     func localFileMetadataFromOcId(_ ocId: String) -> NextcloudLocalFileMetadataTable? {
-        if let metadata = ncDatabase().objects(NextcloudLocalFileMetadataTable.self).filter("ocId == %@", ocId).first {
+        if let metadata = ncDatabase().objects(NextcloudLocalFileMetadataTable.self).filter(
+            "ocId == %@", ocId
+        ).first {
             return NextcloudLocalFileMetadataTable(value: metadata)
         }
 
@@ -41,10 +43,14 @@ extension NextcloudFilesDatabaseManager {
                 newLocalFileMetadata.exifLongitude = "-1"
 
                 database.add(newLocalFileMetadata, update: .all)
-                Logger.ncFilesDatabase.debug("Added local file metadata from item metadata. ocID: \(itemMetadata.ocId, privacy: .public), etag: \(itemMetadata.etag, privacy: .public), fileName: \(itemMetadata.fileName, privacy: .public)")
+                Logger.ncFilesDatabase.debug(
+                    "Added local file metadata from item metadata. ocID: \(itemMetadata.ocId, privacy: .public), etag: \(itemMetadata.etag, privacy: .public), fileName: \(itemMetadata.fileName, privacy: .public)"
+                )
             }
-        } catch let error {
-            Logger.ncFilesDatabase.error("Could not add local file metadata from item metadata. ocID: \(itemMetadata.ocId, privacy: .public), etag: \(itemMetadata.etag, privacy: .public), fileName: \(itemMetadata.fileName, privacy: .public), received error: \(error.localizedDescription, privacy: .public)")
+        } catch {
+            Logger.ncFilesDatabase.error(
+                "Could not add local file metadata from item metadata. ocID: \(itemMetadata.ocId, privacy: .public), etag: \(itemMetadata.etag, privacy: .public), fileName: \(itemMetadata.fileName, privacy: .public), received error: \(error.localizedDescription, privacy: .public)"
+            )
         }
     }
 
@@ -53,34 +59,42 @@ extension NextcloudFilesDatabaseManager {
 
         do {
             try database.write {
-                let results = database.objects(NextcloudLocalFileMetadataTable.self).filter("ocId == %@", ocId)
+                let results = database.objects(NextcloudLocalFileMetadataTable.self).filter(
+                    "ocId == %@", ocId)
                 database.delete(results)
             }
-        } catch let error {
-            Logger.ncFilesDatabase.error("Could not delete local file metadata with ocId: \(ocId, privacy: .public), received error: \(error.localizedDescription, privacy: .public)")
+        } catch {
+            Logger.ncFilesDatabase.error(
+                "Could not delete local file metadata with ocId: \(ocId, privacy: .public), received error: \(error.localizedDescription, privacy: .public)"
+            )
         }
     }
 
-    private func sortedLocalFileMetadatas(_ metadatas: Results<NextcloudLocalFileMetadataTable>) -> [NextcloudLocalFileMetadataTable] {
+    private func sortedLocalFileMetadatas(_ metadatas: Results<NextcloudLocalFileMetadataTable>)
+        -> [NextcloudLocalFileMetadataTable]
+    {
         let sortedMetadatas = metadatas.sorted(byKeyPath: "fileName", ascending: true)
         return Array(sortedMetadatas.map { NextcloudLocalFileMetadataTable(value: $0) })
     }
 
     func localFileMetadatas(account: String) -> [NextcloudLocalFileMetadataTable] {
-        let results = ncDatabase().objects(NextcloudLocalFileMetadataTable.self).filter("account == %@", account)
+        let results = ncDatabase().objects(NextcloudLocalFileMetadataTable.self).filter(
+            "account == %@", account)
         return sortedLocalFileMetadatas(results)
     }
 
     func localFileItemMetadatas(account: String) -> [NextcloudItemMetadataTable] {
         let localFileMetadatas = localFileMetadatas(account: account)
-        let localFileMetadatasOcIds = Array(localFileMetadatas.map { $0.ocId })
+        let localFileMetadatasOcIds = Array(localFileMetadatas.map(\.ocId))
 
         var itemMetadatas: [NextcloudItemMetadataTable] = []
 
         for ocId in localFileMetadatasOcIds {
             guard let itemMetadata = itemMetadataFromOcId(ocId) else {
-                Logger.ncFilesDatabase.error("Could not find matching item metadata for local file metadata with ocId: \(ocId, privacy: .public) with request from account: \(account)")
-                continue;
+                Logger.ncFilesDatabase.error(
+                    "Could not find matching item metadata for local file metadata with ocId: \(ocId, privacy: .public) with request from account: \(account)"
+                )
+                continue
             }
 
             itemMetadatas.append(NextcloudItemMetadataTable(value: itemMetadata))