URL.init(filePath:) should resolve against the base URL before checking if the file is a directory (#606)

Author: jrflat

Sources/FoundationEssentials/String/String+Path.swift

@@ -199,6 +199,16 @@ extension String {
         return result
     }
 
+    internal func merging(relativePath: String) -> String {
+        guard relativePath.utf8.first != UInt8(ascii: "/") else {
+            return relativePath
+        }
+        guard let basePathEnd = self.utf8.lastIndex(of: UInt8(ascii: "/")) else {
+            return relativePath
+        }
+        return self[...basePathEnd] + relativePath
+    }
+
     internal var removingDotSegments: String {
         let input = self.utf8
         guard !input.isEmpty else {

Sources/FoundationEssentials/URL/URL.swift

@@ -1011,12 +1011,11 @@ public struct URL: Equatable, Sendable, Hashable {
         guard let _baseParseInfo else {
             return relativePath
         }
-        let basePath = _baseParseInfo.path
+        let basePath = String(_baseParseInfo.path)
         if _baseParseInfo.hasAuthority && basePath.isEmpty {
             return "/" + relativePath
         }
-        let basePathEnd = basePath.utf8.lastIndex(of: UInt8(ascii: "/")) ?? basePath.startIndex
-        return basePath[..<basePathEnd] + "/" + relativePath
+        return basePath.merging(relativePath: relativePath)
     }
 
     /// Calculate the "merged" path that is resovled against the base URL
@@ -1295,7 +1294,7 @@ public struct URL: Equatable, Sendable, Hashable {
         }
     }
 
-    private func fileSystemPath(for urlPath: String) -> String {
+    private static func fileSystemPath(for urlPath: String) -> String {
         var result = urlPath
         if result.count > 1 && result.utf8.last == UInt8(ascii: "/") {
             _ = result.popLast()
@@ -1305,7 +1304,7 @@ public struct URL: Equatable, Sendable, Hashable {
     }
 
     var fileSystemPath: String {
-        return fileSystemPath(for: path())
+        return URL.fileSystemPath(for: path())
     }
 
     /// Returns the path component of the URL if present, otherwise returns an empty string.
@@ -1382,7 +1381,7 @@ public struct URL: Equatable, Sendable, Hashable {
             }
         }
         #endif
-        return fileSystemPath(for: relativePath())
+        return URL.fileSystemPath(for: relativePath())
     }
 
     private func relativePath(percentEncoded: Bool = true) -> String {
@@ -2098,11 +2097,12 @@ extension URL {
             guard !isAbsolute, let baseURL else {
                 return filePath
             }
+            let basePath = baseURL.path()
             #if os(Windows)
             let urlPath = filePath.replacing(UInt8(ascii: "\\"), with: UInt8(ascii: "/"))
-            return baseURL.mergedPath(for: urlPath).replacing(UInt8(ascii: "/"), with: UInt8(ascii: "\\"))
+            return URL.fileSystemPath(for: basePath.merging(relativePath: urlPath)).replacing(UInt8(ascii: "/"), with: UInt8(ascii: "\\"))
             #else
-            return baseURL.mergedPath(for: filePath)
+            return URL.fileSystemPath(for: basePath.merging(relativePath: filePath))
             #endif
         }
 
@@ -2188,9 +2188,9 @@ extension URL {
             if isFileURL {
                 let filePath: String
                 if newPath.utf8.first == slash {
-                    filePath = fileSystemPath(for: newPath)
+                    filePath = URL.fileSystemPath(for: newPath)
                 } else {
-                    filePath = fileSystemPath(for: mergedPath(for: newPath))
+                    filePath = URL.fileSystemPath(for: mergedPath(for: newPath))
                 }
                 isDirectory = URL.isDirectory(filePath)
             } else {

Tests/FoundationEssentialsTests/URLTests.swift

@@ -330,6 +330,28 @@ final class URLTests : XCTestCase {
         try FileManager.default.removeItem(at: URL(filePath: "\(tempDirectory.path)/tmp-dir"))
     }
 
+    func testURLFilePathRelativeToBase() throws {
+        try FileManagerPlayground {
+            Directory("dir") {
+                "Foo"
+                "Bar"
+            }
+        }.test {
+            let currentDirectoryPath = $0.currentDirectoryPath
+            let baseURL = URL(filePath: currentDirectoryPath, directoryHint: .isDirectory)
+            let relativePath = "dir"
+
+            let url1 = URL(filePath: relativePath, directoryHint: .isDirectory, relativeTo: baseURL)
+
+            let url2 = URL(filePath: relativePath, directoryHint: .checkFileSystem, relativeTo: baseURL)
+            XCTAssertEqual(url1, url2, "\(url1) was not equal to \(url2)")
+
+            // directoryHint is `.inferFromPath` by default
+            let url3 = URL(filePath: relativePath + "/", relativeTo: baseURL)
+            XCTAssertEqual(url1, url3, "\(url1) was not equal to \(url3)")
+        }
+    }
+
     func testAppendFamily() throws {
         let base = URL(string: "https://www.example.com")!