Bug: Fixed issue where the GitShell would crash when no data is present

Author: nanashili

Sources/Version-Control/Base/Core/GitShell.swift

@@ -42,122 +42,127 @@ public struct GitShell {
         var stderr = ""
 
         let process = Process()
-        process.launchPath = "/usr/bin/env"
+        process.executableURL = URL(fileURLWithPath: "/usr/bin/env")
         process.arguments = ["git"] + args
-        process.currentDirectoryPath = path.relativePath
+        process.currentDirectoryURL = path
 
         let stdoutPipe = Pipe()
         let stderrPipe = Pipe()
         process.standardOutput = stdoutPipe
         process.standardError = stderrPipe
 
-        let environment = ProcessInfo.processInfo.environment
-
-        // Set TERM to 'dumb' in the environment
-        var gitEnvironment = environment
+        var gitEnvironment = ProcessInfo.processInfo.environment
         gitEnvironment["TERM"] = "dumb"
 
         if let environment = options?.env {
-            process.environment = environment
+            gitEnvironment.merge(environment) { (_, new) in new }
         }
 
         process.environment = gitEnvironment
 
-        process.launch()
+        do {
+            try process.run()
+        } catch {
+            throw ProcessError.launchFailed(error.localizedDescription)
+        }
+
+        let stdoutHandle = stdoutPipe.fileHandleForReading
+        let stderrHandle = stderrPipe.fileHandleForReading
+
+        stdoutHandle.readabilityHandler = { handle in
+            let data = handle.availableData
+            if let output = String(data: data, encoding: .utf8) {
+                stdout += output
+            }
+        }
+
+        stderrHandle.readabilityHandler = { handle in
+            let data = handle.availableData
+            if let output = String(data: data, encoding: .utf8) {
+                stderr += output
+            }
+        }
 
         let commandLineURL = "/usr/bin/env git " + args.joined(separator: " ")
         print("Command Line URL: \(commandLineURL)")
 
-        let stdoutData = stdoutPipe.fileHandleForReading.readDataToEndOfFile()
-        if let output = String(data: stdoutData, encoding: .utf8) {
-            stdout = output
+        let timeout: TimeInterval = 30 // Adjust this value as needed
+        let timeoutDate = Date(timeIntervalSinceNow: timeout)
+
+        while process.isRunning && Date() < timeoutDate {
+            Thread.sleep(forTimeInterval: 0.1)
         }
 
-        let stderrData = stderrPipe.fileHandleForReading.readDataToEndOfFile()
-        if let errorOutput = String(data: stderrData, encoding: .utf8) {
-            stderr = errorOutput
+        if process.isRunning {
+            process.terminate()
+            throw ProcessError.timeout
         }
 
-        process.waitUntilExit()
+        stdoutHandle.readabilityHandler = nil
+        stderrHandle.readabilityHandler = nil
 
-        let combinedOuput = stdout + stderr
+        let exitCode = Int(process.terminationStatus)
 
-        print("Function: \(name), Output: \(stdout)")
+        let combinedOutput = stdout + stderr
 
         let result = IGitResult(stdout: stdout,
                                 stderr: stderr,
-                                exitCode: Int(process.terminationStatus),
+                                exitCode: exitCode,
                                 gitError: nil,
                                 gitErrorDescription: nil,
-                                combinedOutput: stdout + stderr,
+                                combinedOutput: combinedOutput,
                                 path: path.relativePath.escapedWhiteSpaces())
 
-        let exitCode = result.exitCode
-        var gitError: GitError?
-        let acceptableExitCode = options?.successExitCodes != nil
-            ? options?.successExitCodes?.contains(exitCode)
-            : false
-
-        if !acceptableExitCode! {
-            gitError = parseError(stderr: result.stderr)
-            if gitError == nil {
-                gitError = parseError(stderr: result.stdout)
-            }
-        }
+        let acceptableExitCode = options?.successExitCodes?.contains(exitCode) ?? (exitCode == 0)
 
-        let gitErrorDescription = gitError != nil ? getDescriptionError(gitError!) : nil
+        if !acceptableExitCode {
+            let gitError = parseError(stderr: result.stderr) ?? parseError(stderr: result.stdout)
+            let gitErrorDescription = gitError.map { getDescriptionError($0) }
 
-        var gitResult = IGitResult(stdout: stdout,
-                                   stderr: stderr,
-                                   exitCode: exitCode,
-                                   gitError: gitError,
-                                   gitErrorDescription: gitErrorDescription,
-                                   combinedOutput: combinedOuput,
-                                   path: path.relativePath.escapedWhiteSpaces())
+            var gitResult = IGitResult(stdout: stdout,
+                                       stderr: stderr,
+                                       exitCode: exitCode,
+                                       gitError: gitError,
+                                       gitErrorDescription: gitErrorDescription ?? "Unknown error",
+                                       combinedOutput: combinedOutput,
+                                       path: path.relativePath.escapedWhiteSpaces())
 
-        var acceptableError = true
+            let acceptableError = gitError.map { options?.expectedErrors?.contains($0) ?? false } ?? false
 
-        if gitError != nil && options?.expectedErrors != nil {
-            acceptableError = ((options?.expectedErrors?.contains(gitError!)) != nil)
-        }
+            if acceptableError {
+                return gitResult
+            }
 
-        if (gitError != nil && acceptableError) || acceptableError {
-            return gitResult
-        }
+            var errorMessage = [String]()
+            errorMessage.append("`git \(args.joined(separator: " "))` exited with an unexpected code: \(exitCode)")
 
-        var errorMessage = [String]()
+            if !result.stdout.isEmpty {
+                errorMessage.append("stdout:")
+                errorMessage.append(result.stdout)
+            }
 
-        errorMessage.append("`git \(args.joined(separator: " "))` exited with an unexpected code: \(exitCode)")
+            if !result.stderr.isEmpty {
+                errorMessage.append("stderr:")
+                errorMessage.append(result.stderr)
+            }
 
-        if !result.stdout.isEmpty {
-            errorMessage.append("stdout:")
-            errorMessage.append(result.stdout)
-        }
+            if let gitError = gitError {
+                errorMessage.append("(The error was parsed as \(gitError): \(gitErrorDescription ?? ""))")
+            }
 
-        if !result.stderr.isEmpty {
-            errorMessage.append("stderr:")
-            errorMessage.append(result.stderr)
-        }
+            if gitError == .PushWithFileSizeExceedingLimit {
+                if let files = getFileFromExceedsError(error: errorMessage.joined(separator: "\n")) {
+                    gitResult.gitErrorDescription? += "\n\nFile causing error:\n\n" + files.joined(separator: "\n")
+                }
+            }
 
-        if let gitError = gitError {
-            errorMessage.append("(The error was parsed as \(gitError): \(gitErrorDescription ?? ""))")
+            throw ProcessError.unexpectedExitCode(exitCode)
         }
 
-        let errorString = errorMessage.joined(separator: "\n")
-
-        print(errorMessage.joined(separator: "\n"))
-
-        if gitError == GitError.PushWithFileSizeExceedingLimit {
-            let result = getFileFromExceedsError(error: errorMessage.joined())
-            let files = result.joined(separator: "\n")
-
-            if !files.isEmpty {
-                gitResult.gitErrorDescription! += "\n\nFile causing error:\n\n" + files
-            }
-        }
+        try? stdoutHandle.close()
+        try? stderrHandle.close()
 
-        throw GitErrorParser(result: gitResult,
-                             args: args)
+        return result
     }
 
     /**
@@ -291,7 +296,7 @@ public struct GitShell {
         }
     }
 
-    func getFileFromExceedsError(error: String) -> [String] {
+    func getFileFromExceedsError(error: String) -> [String]? {
         do {
             let beginRegex = try NSRegularExpression(
                 pattern: "(^remote:\\serror:\\sFile\\s)",
@@ -314,7 +319,7 @@ public struct GitShell {
             )
 
             if beginMatches.count != endMatches.count {
-                return []
+                return nil  // Changed from [] to nil
             }
 
             var files: [String] = []
@@ -328,9 +333,9 @@ public struct GitShell {
                 files.append(file)
             }
 
-            return files
+            return files.isEmpty ? nil : files  // Return nil if no files found
         } catch {
-            return []
+            return nil  // Changed from [] to nil
         }
     }
 }

Sources/Version-Control/Base/Core/ProcessError.swift

@@ -0,0 +1,29 @@
+//
+//  ProcessError.swift
+//  
+//
+//  Created by Tihan-Nico Paxton on 2024/07/02.
+//
+
+// Process Specific Errors
+public enum ProcessError: Error {
+    case launchFailed(String)
+    case timeout
+    case unexpectedExitCode(Int)
+    case outputParsingFailed
+}
+
+extension ProcessError {
+    var errorDescription: String? {
+        switch self {
+        case .launchFailed(let reason):
+            return "Failed to launch process: \(reason)"
+        case .timeout:
+            return "Process execution timed out"
+        case .unexpectedExitCode(let code):
+            return "Process exited with unexpected code: \(code)"
+        case .outputParsingFailed:
+            return "Failed to parse process output"
+        }
+    }
+}