More coverage

Sources/Path+FileManager.swift

@@ -1,4 +1,7 @@
 import Foundation
+#if os(Linux)
+import Glibc
+#endif
 
 public extension Path {
     //MARK: File Management
@@ -25,6 +28,11 @@ public extension Path {
         if overwrite, to.isFile, isFile {
             try FileManager.default.removeItem(at: to.url)
         }
+    #if os(Linux) && !swift(>=5.1) // check if fixed
+        if !overwrite, to.isFile {
+            throw CocoaError.error(.fileWriteFileExists)
+        }
+    #endif
         try FileManager.default.copyItem(atPath: string, toPath: to.string)
         return to
     }
@@ -53,20 +61,16 @@ public extension Path {
     @discardableResult
     func copy(into: Path, overwrite: Bool = false) throws -> Path {
         if !into.exists {
-            try FileManager.default.createDirectory(at: url, withIntermediateDirectories: true)
+            try FileManager.default.createDirectory(at: into.url, withIntermediateDirectories: true)
         }
         let rv = into/basename()
         if overwrite, rv.isFile {
             try rv.delete()
         }
-    #if os(Linux)
-    #if swift(>=5.1)
-        // check if fixed
-    #else
+    #if os(Linux) && !swift(>=5.1) // check if fixed
         if !overwrite, rv.isFile {
             throw CocoaError.error(.fileWriteFileExists)
         }
-    #endif
     #endif
         try FileManager.default.copyItem(at: url, to: rv.url)
         return rv
@@ -142,13 +146,26 @@ public extension Path {
     }
 
     /**
-     Creates an empty file at this path.
+     Creates an empty file at this path or if the file exists, updates its modification time.
      - Returns: `self` to allow chaining.
      */
     @inlinable
     @discardableResult
     func touch() throws -> Path {
-        return try "".write(to: self)
+        if !exists {
+            guard FileManager.default.createFile(atPath: string, contents: nil) else {
+                throw CocoaError.error(.fileWriteUnknown)
+            }
+        } else {
+        #if os(Linux)
+            let fd = open(string, O_WRONLY)
+            defer { close(fd) }
+            futimens(fd, nil)
+        #else
+            try FileManager.default.setAttributes([.modificationDate: Date()], ofItemAtPath: string)
+        #endif
+        }
+        return self
     }
 
     /**

Tests/PathTests/PathTests.swift

@@ -169,6 +169,8 @@ class PathTests: XCTestCase {
             try root.foo.touch().copy(to: root.bar)
             XCTAssert(root.foo.isFile)
             XCTAssert(root.bar.isFile)
+            XCTAssertThrowsError(try root.foo.copy(to: root.bar))
+            try root.foo.copy(to: root.bar, overwrite: true)
         }
     }
 
@@ -182,14 +184,25 @@ class PathTests: XCTestCase {
                 XCTAssertTrue(bar1.exists)
                 XCTAssertTrue(bar2.exists)
             }
+
+            // test creates intermediary directories
+            try bar1.copy(into: root1.create.directories)
+
+            // test doesn’t replace file if “copy into” a file
+            let d = try root1.fuz.touch()
+            XCTAssertThrowsError(try root1.baz.touch().copy(into: d))
+            XCTAssert(d.isFile)
+            XCTAssert(root1.baz.isFile)
         }
     }
 
     func testMoveTo() throws {
-        try Path.mktemp { root in
-            try root.foo.touch().move(to: root.bar)
-            XCTAssertFalse(root.foo.exists)
-            XCTAssert(root.bar.isFile)
+        try Path.mktemp { tmpdir in
+            try tmpdir.foo.touch().move(to: tmpdir.bar)
+            XCTAssertFalse(tmpdir.foo.exists)
+            XCTAssert(tmpdir.bar.isFile)
+            XCTAssertThrowsError(try tmpdir.foo.touch().move(to: tmpdir.bar))
+            try tmpdir.foo.move(to: tmpdir.bar, overwrite: true)
         }
     }
 
@@ -203,6 +216,17 @@ class PathTests: XCTestCase {
                 XCTAssertFalse(bar1.exists)
                 XCTAssertTrue(bar2.exists)
             }
+
+            // test creates intermediary directories
+            try root1.baz.touch().move(into: root1.create.directories)
+            XCTAssertFalse(root1.baz.exists)
+            XCTAssert(root1.create.directories.baz.isFile)
+
+            // test doesn’t replace file if “move into” a file
+            let d = try root1.fuz.touch()
+            XCTAssertThrowsError(try root1.baz.touch().move(into: d))
+            XCTAssert(d.isFile)
+            XCTAssert(root1.baz.isFile)
         }
     }
 
@@ -225,7 +249,7 @@ class PathTests: XCTestCase {
         XCTAssertEqual(Path.root.string, "/")
         XCTAssertEqual(Path.home.string, NSHomeDirectory())
         XCTAssertEqual(Path.documents.string, NSHomeDirectory() + "/Documents")
-    #if os(macOS)
+    #if !os(Linux)
         XCTAssertEqual(Path.caches.string, NSHomeDirectory() + "/Library/Caches")
         XCTAssertEqual(Path.cwd.string, FileManager.default.currentDirectoryPath)
         XCTAssertEqual(Path.applicationSupport.string, NSHomeDirectory() + "/Library/Application Support")
@@ -298,6 +322,9 @@ class PathTests: XCTestCase {
             let now2 = Date().timeIntervalSince1970.rounded(.down)
             XCTAssertNotEqual(now1, now2)
             XCTAssertEqual(foo.mtime?.timeIntervalSince1970.rounded(.down), now2)  //FIXME flakey
+
+            XCTAssertNil(tmpdir.void.mtime)
+            XCTAssertNil(tmpdir.void.ctime)
         }
     }
 
@@ -334,14 +361,15 @@ class PathTests: XCTestCase {
         _ = Bundle.main.sharedFrameworks
     }
 
-    func testDataExentsions() throws {
+    func testDataExtensions() throws {
         let data = try Data(contentsOf: Path(#file)!)
         try Path.mktemp { tmpdir in
             _ = try data.write(to: tmpdir.foo)
+            _ = try data.write(to: tmpdir.foo, atomically: true)
         }
     }
 
-    func testStringExentsions() throws {
+    func testStringExtensions() throws {
         let string = try String(contentsOf: Path(#file)!)
         try Path.mktemp { tmpdir in
             _ = try string.write(to: tmpdir.foo)
@@ -353,4 +381,20 @@ class PathTests: XCTestCase {
         _ = try FileHandle(forWritingAt: Path(#file)!)
         _ = try FileHandle(forUpdatingAt: Path(#file)!)
     }
+
+    func testSort() {
+        XCTAssertEqual([Path.root.a, Path.root.c, Path.root.b].sorted(), [Path.root.a, Path.root.b, Path.root.c])
+    }
+
+    func testLock() throws {
+    #if !os(Linux)
+        try Path.mktemp { tmpdir in
+            let bar = try tmpdir.bar.touch()
+            try bar.lock()
+            XCTAssertThrowsError(try bar.touch())
+            try bar.unlock()
+            try bar.touch()
+        }
+    #endif
+    }
 }

Tests/PathTests/XCTestManifests.swift

@@ -9,7 +9,7 @@ extension PathTests {
         ("testConcatenation", testConcatenation),
         ("testCopyInto", testCopyInto),
         ("testCopyTo", testCopyTo),
-        ("testDataExentsions", testDataExentsions),
+        ("testDataExtensions", testDataExtensions),
         ("testDelete", testDelete),
         ("testDynamicMember", testDynamicMember),
         ("testEnumeration", testEnumeration),
@@ -20,6 +20,7 @@ extension PathTests {
         ("testFilesystemAttributes", testFilesystemAttributes),
         ("testIsDirectory", testIsDirectory),
         ("testJoin", testJoin),
+        ("testLock", testLock),
         ("testMkpathIfExists", testMkpathIfExists),
         ("testMktemp", testMktemp),
         ("testMoveInto", testMoveInto),
@@ -28,8 +29,9 @@ extension PathTests {
         ("testRelativePathCodable", testRelativePathCodable),
         ("testRelativeTo", testRelativeTo),
         ("testRename", testRename),
+        ("testSort", testSort),
         ("testStringConvertibles", testStringConvertibles),
-        ("testStringExentsions", testStringExentsions),
+        ("testStringExtensions", testStringExtensions),
         ("testTimes", testTimes),
     ]
 }