CommandLineToolkit

1
import CLTExtensions
2
#if canImport(Darwin)
3
import Darwin
4
#endif
5
#if canImport(Glibc)
6
import Glibc
7
#endif
8
import Foundation
9
import PathLib
10

11
public final class TemporaryFolder {
12
    public let absolutePath: AbsolutePath
13
    private let deleteOnDealloc: Bool
14
    
15
    public init(
16
        containerPath: AbsolutePath? = nil,
17
        prefix: String = "TemporaryFolder",
18
        deleteOnDealloc: Bool = true
19
    ) throws {
20
        if let containerPath = containerPath {
21
            try FileManager.default.createDirectory(atPath: containerPath)
22
        }
23
        let containerPath = containerPath ?? AbsolutePath(NSTemporaryDirectory())
24
        let pathTemplate = containerPath.appending("\(prefix).XXXXXX")
25
        var templateBytes = [UInt8](pathTemplate.pathString.utf8).map { Int8($0) } + [Int8(0)]
26
        if mkdtemp(&templateBytes) == nil {
27
            throw ErrnoError.failedToCreateTemporaryFolder(pathTemplate, code: errno)
28
        }
29
        
30
        let resultingPath = String(cString: templateBytes)
31
        let urlValues = try URL(fileURLWithPath: resultingPath).resourceValues(forKeys: [.canonicalPathKey])
32
        guard let canonicalPath = urlValues.canonicalPath else {
33
            throw UnknownCanonicalPath(path: resultingPath)
34
        }
35
        
36
        self.absolutePath = AbsolutePath(canonicalPath)
37
        self.deleteOnDealloc = deleteOnDealloc
38
    }
39
    
40
    deinit {
41
        if deleteOnDealloc {
42
            try? FileManager.default.removeItem(atPath: absolutePath.pathString)
43
        } else {
44
            rmdir(absolutePath.pathString)
45
        }
46
    }
47
    
48
    public func pathWith(components: [String]) -> AbsolutePath {
49
        return absolutePath.appending(components: components)
50
    }
51
    
52
    @discardableResult
53
    public func createDirectory(components: [String], attributes: [FileAttributeKey: Any]? = nil) throws -> AbsolutePath {
54
        let path = pathWith(components: components)
55
        try FileManager.default.createDirectory(atPath: path, attributes: attributes)
56
        return path
57
    }
58
    
59
    @discardableResult
60
    public func createFile(components: [String] = [], filename: String, contents: Data? = nil, attributes: [FileAttributeKey: Any]? = nil) throws -> AbsolutePath {
61
        let container = try createDirectory(components: components)
62
        let path = container.appending(filename)
63
        FileManager.default.createFile(atPath: path.pathString, contents: contents, attributes: attributes)
64
        return path
65
    }
66
    
67
    @discardableResult
68
    public func createFile(components: [String] = [], filename: String, contents: String, attributes: [FileAttributeKey: Any]? = nil) throws -> AbsolutePath {
69
        return try createFile(components: components, filename: filename, contents: contents.dataUsingUtf8(), attributes: attributes)
70
    }
71
    
72
    public func createSymbolicLink(at path: RelativePath, destination: Path) throws -> AbsolutePath {
73
        let symbolicLinkPath = pathWith(components: path.components)
74
        try FileManager.default.createSymbolicLink(
75
            atPath: symbolicLinkPath.pathString,
76
            withDestinationPath: destination.pathString
77
        )
78
        return symbolicLinkPath
79
    }
80
    
81
    public static func == (left: TemporaryFolder, right: TemporaryFolder) -> Bool {
82
        return left.absolutePath == right.absolutePath
83
    }
84
    
85
    public func hash(into hasher: inout Hasher) {
86
        hasher.combine(absolutePath)
87
    }
88
}
89