deprecated createSymlink in PathShims

Author: tgymnich

Sources/TSCBasic/PathShims.swift

@@ -61,6 +61,7 @@ public func makeDirectories(_ path: AbsolutePath) throws {
 
 /// Creates a symbolic link at `path` whose content points to `dest`.  If `relative` is true, the symlink contents will
 /// be a relative path, otherwise it will be absolute.
+@available(*, deprecated, renamed: "localFileSystem.createSymbolicLink")
 public func createSymlink(_ path: AbsolutePath, pointingAt dest: AbsolutePath, relative: Bool = true) throws {
     let destString = relative ? dest.relative(to: path.parentDirectory).pathString : dest.pathString
     try FileManager.default.createSymbolicLink(atPath: path.pathString, withDestinationPath: destString)

Tests/TSCBasicTests/FileSystemTests.swift

@@ -37,7 +37,7 @@ class FileSystemTests: XCTestCase {
 
                 // isSymlink()
                 let sym = tempDirPath.appending(component: "hello")
-                try! createSymlink(sym, pointingAt: file.path)
+                try! fs.createSymbolicLink(sym, pointingAt: file.path)
                 XCTAssertTrue(fs.isSymlink(sym))
                 XCTAssertTrue(fs.isFile(sym))
                 XCTAssertEqual(try fs.getFileInfo(sym).fileType, .typeSymbolicLink)
@@ -46,15 +46,15 @@ class FileSystemTests: XCTestCase {
                 // isExecutableFile
                 let executable = tempDirPath.appending(component: "exec-foo")
                 let executableSym = tempDirPath.appending(component: "exec-sym")
-                try! createSymlink(executableSym, pointingAt: executable)
+                try! fs.createSymbolicLink(executableSym, pointingAt: executable)
                 let stream = BufferedOutputByteStream()
                 stream <<< """
                     #!/bin/sh
                     set -e
                     exit
 
                     """
-                try! localFileSystem.writeFileContents(executable, bytes: stream.bytes)
+                try! fs.writeFileContents(executable, bytes: stream.bytes)
                 try! Process.checkNonZeroExit(args: "chmod", "+x", executable.pathString)
                 XCTAssertTrue(fs.isExecutableFile(executable))
                 XCTAssertTrue(fs.isExecutableFile(executableSym))
@@ -94,7 +94,7 @@ class FileSystemTests: XCTestCase {
 
             // Source and target exist.
 
-            try createSymlink(source, pointingAt: target)
+            try fs.createSymbolicLink(source, pointingAt: target)
             XCTAssertEqual(fs.exists(source), true)
             XCTAssertEqual(fs.exists(source, followSymlink: true), true)
             XCTAssertEqual(fs.exists(source, followSymlink: false), true)
@@ -563,7 +563,7 @@ class FileSystemTests: XCTestCase {
             try fs.createDirectory(dir, recursive: true)
             try fs.writeFileContents(foo, bytes: "")
             try fs.writeFileContents(bar, bytes: "")
-            try createSymlink(sym, pointingAt: foo)
+            try fs.createSymbolicLink(sym, pointingAt: foo)
 
             // Set foo to unwritable.
             try fs.chmod(.userUnWritable, path: foo)

Tests/TSCBasicTests/POSIXTests.swift

@@ -26,14 +26,14 @@ class POSIXTests : XCTestCase {
                 XCTAssertTrue(localFileSystem.isDirectory(dirPath))
 
                 let sym = dirPath.appending(component: "hello")
-                try createSymlink(sym, pointingAt: file.path)
+                try localFileSystem.createSymbolicLink(sym, pointingAt: file.path)
                 XCTAssertTrue(localFileSystem.exists(sym))
                 XCTAssertTrue(localFileSystem.isFile(sym))
                 XCTAssertFalse(localFileSystem.isDirectory(sym))
 
                 try withTemporaryDirectory(removeTreeOnDeinit: true) { dir2Path in
                     let dirSym = dirPath.appending(component: "dir2")
-                    try createSymlink(dirSym, pointingAt: dir2Path)
+                    try localFileSystem.createSymbolicLink(dirSym, pointingAt: dir2Path)
                     XCTAssertTrue(localFileSystem.exists(dirSym))
                     XCTAssertFalse(localFileSystem.isFile(dirSym))
                     XCTAssertTrue(localFileSystem.isDirectory(dirSym))

Tests/TSCBasicTests/PathShimTests.swift

@@ -29,7 +29,7 @@ class PathShimTests : XCTestCase {
             let fldrPath = tmpDirPath.appending(component: "fldr")
 
             // Create a symbolic link pointing at the (so far non-existent) directory.
-            try! createSymlink(slnkPath, pointingAt: fldrPath, relative: true)
+            try! localFileSystem.createSymbolicLink(slnkPath, pointingAt: fldrPath)
 
             // Resolving the symlink should not yet change anything.
             XCTAssertEqual(resolveSymlinks(slnkPath), slnkPath)
@@ -113,7 +113,7 @@ class WalkTests : XCTestCase {
 
             try! makeDirectories(tmpDirPath.appending(component: "foo"))
             try! makeDirectories(tmpDirPath.appending(components: "bar", "baz", "goo"))
-            try! createSymlink(tmpDirPath.appending(components: "foo", "symlink"), pointingAt: tmpDirPath.appending(component: "bar"), relative: true)
+            try! localFileSystem.createSymbolicLink(tmpDirPath.appending(components: "foo", "symlink"), pointingAt: tmpDirPath.appending(component: "bar"))
 
             XCTAssertTrue(localFileSystem.isSymlink(tmpDirPath.appending(components: "foo", "symlink")))
             XCTAssertEqual(resolveSymlinks(tmpDirPath.appending(components: "foo", "symlink")), tmpDirPath.appending(component: "bar"))
@@ -129,8 +129,8 @@ class WalkTests : XCTestCase {
         try! withTemporaryDirectory(removeTreeOnDeinit: true) { tmpDirPath in
             try! makeDirectories(tmpDirPath.appending(components: "foo", "bar"))
             try! makeDirectories(tmpDirPath.appending(components: "abc", "bar"))
-            try! createSymlink(tmpDirPath.appending(component: "symlink"), pointingAt: tmpDirPath.appending(component: "foo"), relative: true)
-            try! createSymlink(tmpDirPath.appending(components: "foo", "baz"), pointingAt: tmpDirPath.appending(component: "abc"), relative: true)
+            try! localFileSystem.createSymbolicLink(tmpDirPath.appending(component: "symlink"), pointingAt: tmpDirPath.appending(component: "foo"))
+            try! localFileSystem.createSymbolicLink(tmpDirPath.appending(components: "foo", "baz"), pointingAt: tmpDirPath.appending(component: "abc"))
 
             XCTAssertTrue(localFileSystem.isSymlink(tmpDirPath.appending(component: "symlink")))