Basic project creation (#3)

This PR contains the work done to create a new *Hummingbird* project with very basic configuration from the _colibri_ executable, just like the project you could create with the [Hummingbird template](https://github.com/hummingbird-project/template) project in Github.

Reviewed-on: #3
Co-authored-by: Javier Cicchelli <javier@rock-n-code.com>
Co-committed-by: Javier Cicchelli <javier@rock-n-code.com>

Library/Sources/Public/Protocols/Bundleable.swift

@@ -0,0 +1,9 @@
+import Foundation
+
+public protocol Bundleable {
+
+    // MARK: Functions
+    
+    func url(forResource name: String?, withExtension ext: String?, subdirectory subpath: String?) -> URL?
+    
+}

Library/Sources/Public/Protocols/FileServicing.swift

@@ -0,0 +1,28 @@
+import Foundation
+
+public protocol FileServicing {
+    
+    // MARK: Computed
+    
+    var currentFolder: URL { get async }
+    
+    // MARK: Functions
+    
+    func copyFile(from source: URL, to destination: URL) async throws (FileServiceError)
+    func createFolder(at location: URL) async throws (FileServiceError)
+    func deleteItem(at location: URL) async throws (FileServiceError)
+    func isItemExists(at location: URL) async throws (FileServiceError) -> Bool
+    
+}
+
+// MARK: - Errors
+
+public enum FileServiceError: Error, Equatable {
+    case folderNotCreated
+    case itemAlreadyExists
+    case itemEmptyData
+    case itemNotCopied
+    case itemNotDeleted
+    case itemNotExists
+    case itemNotFileURL
+}

Library/Sources/Public/Services/FileService.swift

@@ -0,0 +1,79 @@
+import Foundation
+
+public struct FileService: FileServicing {
+
+    // MARK: Properties
+    
+    private let fileManager: FileManager
+    
+    // MARK: Initialisers
+    
+    public init(fileManager: FileManager = .default) {
+        self.fileManager = fileManager
+    }
+    
+    // MARK: Computed
+    
+    public var currentFolder: URL {
+        get async {
+            .init(at: fileManager.currentDirectoryPath)
+        }
+    }
+    
+    // MARK: Functions
+    
+    public func copyFile(from source: URL, to destination: URL) async throws (FileServiceError) {
+        guard try await !isItemExists(at: destination) else {
+            throw FileServiceError.itemAlreadyExists
+        }
+        
+        var itemData: Data?
+
+        do {
+            itemData = try Data(contentsOf: source)
+        } catch {
+            throw FileServiceError.itemEmptyData
+        }
+        
+        do {
+            try itemData?.write(to: destination, options: .atomic)
+        } catch {
+            throw FileServiceError.itemNotCopied
+        }
+    }
+
+    public func createFolder(at location: URL) async throws (FileServiceError) {
+        guard try await !isItemExists(at: location) else {
+            throw FileServiceError.itemAlreadyExists
+        }
+        
+        do {
+            try fileManager.createDirectory(at: location, withIntermediateDirectories: true)
+        } catch {
+            throw FileServiceError.folderNotCreated
+        }
+    }
+    
+    public func deleteItem(at location: URL) async throws (FileServiceError) {
+        guard try await isItemExists(at: location) else {
+            throw FileServiceError.itemNotExists
+        }
+        
+        do {
+            try fileManager.removeItem(at: location)
+        } catch {
+            throw FileServiceError.itemNotDeleted
+        }
+    }
+    
+    public func isItemExists(at location: URL) async throws (FileServiceError) -> Bool {
+        guard location.isFileURL else {
+            throw FileServiceError.itemNotFileURL
+        }
+        
+        let filePath = location.pathString
+        
+        return fileManager.fileExists(atPath: filePath)
+    }
+    
+}

Library/Sources/Public/Tasks/CopyFilesTask.swift

@@ -0,0 +1,39 @@
+import Foundation
+
+public struct CopyFilesTask {
+
+    // MARK: Properties
+    
+    private let bundle: Bundleable
+    private let fileService: FileServicing
+    
+    // MARK: Initialisers
+    
+    public init(
+        bundle: Bundleable? = nil,
+        fileService: FileServicing
+    ) {
+        self.bundle = bundle ?? Bundle.module
+        self.fileService = fileService
+    }
+
+    // MARK: Functions
+    
+    public func callAsFunction(to rootFolder: URL) async throws (FileServiceError) {
+        for file in File.allCases {
+            guard let source = bundle.url(
+                forResource: file.rawValue,
+                withExtension: nil,
+                subdirectory: file.resourcePath
+            ) else {
+                assertionFailure("URL should have been initialized.")
+                return
+            }
+            
+            let destination = rootFolder.appendingPath(file.filePath)
+
+            try await fileService.copyFile(from: source, to: destination)
+        }
+    }
+    
+}

Library/Sources/Public/Tasks/CreateFoldersTask.swift

@@ -0,0 +1,25 @@
+import Foundation
+
+public struct CreateFoldersTask {
+
+    // MARK: Properties
+
+    private let fileService: FileServicing
+
+    // MARK: Initialisers
+    
+    public init(fileService: FileServicing) {
+        self.fileService = fileService
+    }
+    
+    // MARK: Functions
+    
+    public func callAsFunction(at rootFolder: URL) async throws {
+        let folders = Folder.allCases.map { rootFolder.appendingPath($0.path) }
+        
+        for folder in folders {
+            try await fileService.createFolder(at: folder)
+        }
+    }
+    
+}

Library/Sources/Public/Tasks/CreateRootFolderTask.swift

@@ -0,0 +1,41 @@
+import Foundation
+
+public struct CreateRootFolderTask {
+    
+    // MARK: Properties
+    
+    private let fileService: FileServicing
+    
+    // MARK: Initialisers
+    
+    public init(fileService: FileServicing) {
+        self.fileService = fileService
+    }
+    
+    // MARK: Functions
+    
+    public func callAsFunction(name: String, at location: URL? = nil) async throws -> URL {
+        guard !name.isEmpty else {
+            throw CreateRootFolderError.nameIsEmpty
+        }
+
+        let rootFolder = if let location {
+            location
+        } else {
+            await fileService.currentFolder
+        }
+
+        let newFolder = rootFolder.appendingPath(name)
+
+        try await fileService.createFolder(at: newFolder)
+        
+        return newFolder
+    }
+    
+}
+
+// MARK: - Errors
+
+public enum CreateRootFolderError: Error {
+    case nameIsEmpty
+}

Library/Sources/Public/Tasks/InitGitInFolderTask.swift

@@ -0,0 +1,24 @@
+import Foundation
+
+public struct InitGitInFolderTask {
+
+    // MARK: Initialisers
+    
+    public init() {}
+    
+    // MARK: Functions
+    
+    public func callAsFunction(at rootFolder: URL) async throws (RunProcessError) {
+        let pathCommand = "/usr/bin/git"
+        let pathFolder = rootFolder.pathString
+        
+        var gitInit = RunProcessTask(process: Process())
+        var gitAdd = RunProcessTask(process: Process())
+        var gitCommit = RunProcessTask(process: Process())
+        
+        try await gitInit(path: pathCommand, arguments: ["init", pathFolder])
+        try await gitAdd(path: pathCommand, arguments: ["-C", pathFolder, "add", "."])
+        try await gitCommit(path: pathCommand, arguments: ["-C", pathFolder, "commit", "-m", "Initial commit"])
+    }
+    
+}