Merge pull request #68 from claucambra/bugfix/ignore-files

claucambra · web-flow · commit 41c1a7f93e74 · 2025-04-25T18:58:55.000+08:00
Fix ignored files behaviour
diff --git a/Sources/NextcloudFileProviderKit/Item/Item+CreateUnuploaded.swift b/Sources/NextcloudFileProviderKit/Item/Item+CreateUnuploaded.swift
@@ -0,0 +1,63 @@
+//
+//  Item+CreateUnuploaded.swift
+//  NextcloudFileProviderKit
+//
+//  Created by Claudio Cambra on 25/4/25.
+//
+
+import FileProvider
+
+extension Item {
+    // Creates a file that was previously unuploaded (e.g. a previously ignored/lock file) on server
+    func createUnuploaded(
+        itemTarget: NSFileProviderItem,
+        baseVersion: NSFileProviderItemVersion = NSFileProviderItemVersion(),
+        changedFields: NSFileProviderItemFields,
+        contents newContents: URL?,
+        options: NSFileProviderModifyItemOptions = [],
+        request: NSFileProviderRequest = NSFileProviderRequest(),
+        ignoredFiles: IgnoredFilesMatcher? = nil,
+        domain: NSFileProviderDomain? = nil,
+        forcedChunkSize: Int? = nil,
+        progress: Progress = .init(),
+        dbManager: FilesDatabaseManager
+    ) async -> (Item?, Error?) {
+        guard newContents != nil || domain != nil else {
+            Self.logger.error(
+                """
+                Unable to upload modified item that was previously unuploaded.
+                    filename: \(self.filename, privacy: .public)
+                    either the domain is nil, the provided contents are nil, or both.
+                """
+            )
+            return (nil, NSFileProviderError(.cannotSynchronize))
+        }
+        let modifiedItem = self
+        var contentsLocation = newContents
+        if contentsLocation == nil {
+            assert(domain != nil)
+            guard let domain, let localUrl = await localUrlForContents(domain: domain) else {
+                Self.logger.error(
+                    """
+                    Unable to upload modified item that was previously unuploaded.
+                        filename: \(modifiedItem.filename, privacy: .public)
+                        local url for contents could not be acquired.
+                    """
+                )
+                return (nil, NSFileProviderError(.cannotSynchronize))
+            }
+            contentsLocation = localUrl
+        }
+        return await Self.create(
+            basedOn: itemTarget,
+            contents: contentsLocation,
+            domain: domain,
+            account: account,
+            remoteInterface: remoteInterface,
+            ignoredFiles: ignoredFiles,
+            forcedChunkSize: forcedChunkSize,
+            progress: progress,
+            dbManager: dbManager
+        )
+    }
+}
diff --git a/Sources/NextcloudFileProviderKit/Item/Item+Modify.swift b/Sources/NextcloudFileProviderKit/Item/Item+Modify.swift
@@ -854,13 +854,36 @@ public extension Item {
                     Will delete locally with no remote effect.
                 """
             )
-            return (modifiedItem, nil)
+            guard let modifiedIgnored = modifyUnuploaded(
+                itemTarget: itemTarget,
+                baseVersion: baseVersion,
+                changedFields: changedFields,
+                contents: newContents,
+                options: options,
+                request: request,
+                ignoredFiles: ignoredFiles,
+                domain: domain,
+                forcedChunkSize: forcedChunkSize,
+                progress: progress,
+                dbManager: dbManager
+            ) else {
+                Self.logger.error(
+                    "Unable to modify ignored file, got nil item: \(relativePath, privacy: .public)"
+                )
+                return (nil, NSFileProviderError(.cannotSynchronize))
+            }
+            modifiedItem = modifiedIgnored
+            if #available(macOS 13.0, *) {
+                return (modifiedItem, NSFileProviderError(.excludedFromSync))
+            } else {
+                return (modifiedItem, nil)
+            }
         }
 
         // We are handling an item that is available locally but not on the server -- so create it
         // This can happen when a previously ignored file is no longer ignored
         if !modifiedItem.isUploaded, modifiedItem.isDownloaded, modifiedItem.metadata.etag == "" {
-            return await modifiedItem.modifyUnuploaded(
+            return await modifiedItem.createUnuploaded(
                 itemTarget: itemTarget,
                 baseVersion: baseVersion,
                 changedFields: changedFields,
diff --git a/Sources/NextcloudFileProviderKit/Item/Item+ModifyLockFile.swift b/Sources/NextcloudFileProviderKit/Item/Item+ModifyLockFile.swift
@@ -29,56 +29,24 @@ extension Item {
         )
         assert(isLockFileName(filename), "Should not handle non-lock files here.")
 
-        var modifiedParentItemIdentifier = parentItemIdentifier
-        var modifiedMetadata = metadata
-
-        if changedFields.contains(.filename) {
-            modifiedMetadata.fileName = itemTarget.filename
-            if !isLockFileName(modifiedMetadata.fileName) {
-                modifiedMetadata.classFile = ""
-                // Do the actual upload at the end, not yet
-            }
-        }
-        if changedFields.contains(.contents),
-           let newSize = try? newContents?.resourceValues(forKeys: [.fileSizeKey]).fileSize
-        {
-            modifiedMetadata.size = Int64(newSize)
-        }
-        if changedFields.contains(.parentItemIdentifier) {
-            guard let parentMetadata = dbManager.itemMetadata(
-                ocId: itemTarget.parentItemIdentifier.rawValue
-            ) else {
-                Self.logger.error(
-                    """
-                    Unable to find new parent item identifier during lock file modification.
-                        Lock file: \(self.filename, privacy: .public)
-                    """
-                )
-                return (nil, NSFileProviderError(.cannotSynchronize))
-            }
-            modifiedMetadata.serverUrl = parentMetadata.serverUrl + "/" + parentMetadata.fileName
-            modifiedParentItemIdentifier = .init(parentMetadata.ocId)
-        }
-        if changedFields.contains(.creationDate),
-           let newCreationDate = itemTarget.creationDate,
-           let newCreationDate
-        {
-            modifiedMetadata.creationDate = newCreationDate
-        }
-        if changedFields.contains(.contentModificationDate),
-           let newModificationDate = itemTarget.contentModificationDate,
-           let newModificationDate
-        {
-            modifiedMetadata.date = newModificationDate
-        }
-
-        let modifiedItem = Item(
-            metadata: modifiedMetadata,
-            parentItemIdentifier: modifiedParentItemIdentifier,
-            account: account,
-            remoteInterface: remoteInterface,
+        guard let modifiedItem = modifyUnuploaded(
+            itemTarget: itemTarget,
+            baseVersion: baseVersion,
+            changedFields: changedFields,
+            contents: newContents,
+            options: options,
+            request: request,
+            ignoredFiles: ignoredFiles,
+            domain: domain,
+            forcedChunkSize: forcedChunkSize,
+            progress: progress,
             dbManager: dbManager
-        )
+        ) else {
+            Self.logger.info(
+                "Cannot modify lock file: \(self.filename) as received a nil modified item"
+            )
+            return (nil, NSFileProviderError(.cannotSynchronize))
+        }
 
         if !isLockFileName(modifiedItem.filename) {
             Self.logger.info(
@@ -88,7 +56,7 @@ extension Item {
                     Will proceed with creating item on server (if possible).
                 """
             )
-            return await modifiedItem.modifyUnuploaded(
+            return await modifiedItem.createUnuploaded(
                 itemTarget: itemTarget,
                 baseVersion: baseVersion,
                 changedFields: changedFields,
diff --git a/Sources/NextcloudFileProviderKit/Item/Item+ModifyUnuploaded.swift b/Sources/NextcloudFileProviderKit/Item/Item+ModifyUnuploaded.swift
@@ -8,6 +8,7 @@
 import FileProvider
 
 extension Item {
+    // Just modifies metadata
     func modifyUnuploaded(
         itemTarget: NSFileProviderItem,
         baseVersion: NSFileProviderItemVersion = NSFileProviderItemVersion(),
@@ -20,42 +21,55 @@ extension Item {
         forcedChunkSize: Int? = nil,
         progress: Progress = .init(),
         dbManager: FilesDatabaseManager
-    ) async -> (Item?, Error?) {
-        guard newContents != nil || domain != nil else {
-            Self.logger.error(
-                """
-                Unable to upload modified item that was previously ignored.
-                    filename: \(self.filename, privacy: .public)
-                    either the domain is nil, the provided contents are nil, or both.
-                """
-            )
-            return (nil, NSFileProviderError(.cannotSynchronize))
+    ) -> Item? {
+        var modifiedParentItemIdentifier = parentItemIdentifier
+        var modifiedMetadata = metadata
+
+        if changedFields.contains(.filename) {
+            modifiedMetadata.fileName = itemTarget.filename
+            if !isLockFileName(modifiedMetadata.fileName) {
+                modifiedMetadata.classFile = ""
+                // Do the actual upload at the end, not yet
+            }
+        }
+        if changedFields.contains(.contents),
+           let newSize = try? newContents?.resourceValues(forKeys: [.fileSizeKey]).fileSize
+        {
+            modifiedMetadata.size = Int64(newSize)
         }
-        let modifiedItem = self
-        var contentsLocation = newContents
-        if contentsLocation == nil {
-            assert(domain != nil)
-            guard let domain, let localUrl = await localUrlForContents(domain: domain) else {
+        if changedFields.contains(.parentItemIdentifier) {
+            guard let parentMetadata = dbManager.itemMetadata(
+                ocId: itemTarget.parentItemIdentifier.rawValue
+            ) else {
                 Self.logger.error(
                     """
-                    Unable to upload modified item that was previously ignored.
-                        filename: \(modifiedItem.filename, privacy: .public)
-                        local url for contents could not be acquired.
+                    Unable to find new parent item identifier during unuploaded item modification.
+                        Filename: \(self.filename, privacy: .public)
                     """
                 )
-                return (nil, NSFileProviderError(.cannotSynchronize))
+                return nil
             }
-            contentsLocation = localUrl
+            modifiedMetadata.serverUrl = parentMetadata.serverUrl + "/" + parentMetadata.fileName
+            modifiedParentItemIdentifier = .init(parentMetadata.ocId)
         }
-        return await Self.create(
-            basedOn: itemTarget,
-            contents: contentsLocation,
-            domain: domain,
+        if changedFields.contains(.creationDate),
+           let newCreationDate = itemTarget.creationDate,
+           let newCreationDate
+        {
+            modifiedMetadata.creationDate = newCreationDate
+        }
+        if changedFields.contains(.contentModificationDate),
+           let newModificationDate = itemTarget.contentModificationDate,
+           let newModificationDate
+        {
+            modifiedMetadata.date = newModificationDate
+        }
+
+        return Item(
+            metadata: modifiedMetadata,
+            parentItemIdentifier: modifiedParentItemIdentifier,
             account: account,
             remoteInterface: remoteInterface,
-            ignoredFiles: ignoredFiles,
-            forcedChunkSize: forcedChunkSize,
-            progress: progress,
             dbManager: dbManager
         )
     }
diff --git a/Tests/NextcloudFileProviderKitTests/ItemModifyTests.swift b/Tests/NextcloudFileProviderKitTests/ItemModifyTests.swift
@@ -1349,7 +1349,11 @@ final class ItemModifyTests: XCTestCase {
             ignoredFiles: ignoredMatcher,
             dbManager: Self.dbManager
         )
-        XCTAssertNil(error)
+        if #available(macOS 13.0, *) {
+            XCTAssertEqual(error as? NSFileProviderError, NSFileProviderError(.excludedFromSync))
+        } else {
+            XCTAssertNil(error)
+        }
         XCTAssertNotNil(resultItem)
         XCTAssertEqual(resultItem?.metadata.fileName, "error.bak")
     }

Original file line number	Diff line number	Diff line change
`@@ -1349,7 +1349,11 @@ final class ItemModifyTests: XCTestCase {`
`1349`	`1349`	`ignoredFiles: ignoredMatcher,`
`1350`	`1350`	`dbManager: Self.dbManager`
`1351`	`1351`	`)`
`1352`		`- XCTAssertNil(error)`
	`1352`	`+ if #available(macOS 13.0, *) {`
	`1353`	`+ XCTAssertEqual(error as? NSFileProviderError, NSFileProviderError(.excludedFromSync))`
	`1354`	`+ } else {`
	`1355`	`+ XCTAssertNil(error)`
	`1356`	`+ }`
`1353`	`1357`	`XCTAssertNotNil(resultItem)`
`1354`	`1358`	`XCTAssertEqual(resultItem?.metadata.fileName, "error.bak")`
`1355`	`1359`	`}`