Refactors

Author: FastestMolasses

CodeEdit/Features/LSP/Registry/PackageManagerFactory.swift

@@ -37,6 +37,8 @@ class CargoPackageManager: PackageManagerProtocol {
         let packagePath = installationDirectory.appending(path: source.name)
         print("Installing \(source.name)@\(source.version) in \(packagePath.path)")
 
+        try await initialize(in: packagePath)
+
         do {
             var cargoArgs = ["cargo", "install", "--root", "."]
 
@@ -50,7 +52,7 @@ class CargoPackageManager: PackageManagerProtocol {
                     cargoArgs.append(contentsOf: ["--rev", rev])
                 }
             } else {
-                cargoArgs.append(contentsOf: ["--version", source.version])
+                cargoArgs.append("\(source.name)@\(source.version)")
             }
 
             if let features = source.options["features"] {
@@ -59,7 +61,6 @@ class CargoPackageManager: PackageManagerProtocol {
             if source.options["locked"] == "true" {
                 cargoArgs.append("--locked")
             }
-            cargoArgs.append(source.name)
 
             _ = try await executeInDirectory(in: packagePath.path, cargoArgs)
             print("Successfully installed \(source.name)@\(source.version)")

CodeEdit/Features/LSP/Registry/PackageManagers/CargoPackageManager.swift

@@ -17,15 +17,32 @@ class GithubPackageManager: PackageManagerProtocol {
         self.shellClient = .live()
     }
 
-    func initialize(in packagePath: URL) async throws { }
+    func initialize(in packagePath: URL) async throws {
+        guard await isInstalled() else {
+            throw PackageManagerError.packageManagerNotInstalled
+        }
+
+        do {
+            try createDirectoryStructure(for: packagePath)
+        } catch {
+            throw PackageManagerError.initializationFailed(error.localizedDescription)
+        }
+    }
 
     func install(method: InstallationMethod) async throws {
+        guard case .standardPackage(let source) = method else {
+            throw PackageManagerError.invalidConfiguration
+        }
+
+        let packagePath = installationDirectory.appending(path: source.name)
+        try await initialize(in: packagePath)
+
         switch method {
         case let .binaryDownload(source, url):
-            downloadBinary(source, url)
+            try await downloadBinary(source, url)
             break
         case let .sourceBuild(source, command):
-            installFromSource(source, command)
+            try await installFromSource(source, command)
             break
         case .standardPackage(_), .unknown:
             throw PackageManagerError.invalidConfiguration
@@ -48,12 +65,34 @@ class GithubPackageManager: PackageManagerProtocol {
             return false
         }
     }
-    
-    private func downloadBinary(_ source: PackageSource, _ url: String) {
-        
+
+    private func downloadBinary(_ source: PackageSource, _ url: URL) async throws {
+        let (data, _) = try await URLSession.shared.data(from: url)
+        let fileName = url.lastPathComponent
+        let downloadPath = installationDirectory.appending(path: source.name)
+        let packagePath = downloadPath.appending(path: fileName)
+
+        if !FileManager.default.fileExists(atPath: packagePath.path) {
+            throw RegistryManagerError.downloadFailed(
+                url: url,
+                error: NSError(domain: "Coould not download package", code: -1)
+            )
+        }
+
+        if fileName.hasSuffix(".tar") || fileName.hasSuffix(".zip") {
+            try FileManager.default.unzipItem(at: packagePath, to: downloadPath)
+        }
     }
-    
-    private func installFromSource(_ source: PackageSource, _ command: String) {
-        
+
+    private func installFromSource(_ source: PackageSource, _ command: String) async throws {
+        let installPath = installationDirectory.appending(path: source.name, directoryHint: .isDirectory)
+        do {
+            _ = try await executeInDirectory(in: installPath.path, ["git", "clone", source.repositoryUrl!])
+            let repoPath = installPath.appending(path: source.name, directoryHint: .isDirectory)
+            _ = try await executeInDirectory(in: repoPath.path, [command])
+        } catch {
+            print("Failed to build from source: \(error)")
+            throw PackageManagerError.installationFailed("Source build failed.")
+        }
     }
 }

CodeEdit/Features/LSP/Registry/PackageManagers/GithubPackageManager.swift

@@ -25,7 +25,7 @@ class GolangPackageManager: PackageManagerProtocol {
             try createDirectoryStructure(for: packagePath)
 
             // For Go, we need to set up a proper module structure
-            let goModPath = packagePath.appendingPathComponent("go.mod")
+            let goModPath = packagePath.appending(path: "go.mod")
             if !FileManager.default.fileExists(atPath: goModPath.path) {
                 let moduleName = "codeedit.temp/placeholder"
                 _ = try await executeInDirectory(
@@ -48,6 +48,9 @@ class GolangPackageManager: PackageManagerProtocol {
         try await initialize(in: packagePath)
 
         do {
+            let gobinPath = packagePath.appending(path: "bin", directoryHint: .isDirectory).path
+            var goInstallCommand = ["env", "GOBIN=\(gobinPath)", "go", "install"]
+
             if let gitRef = source.gitReference, let repoUrl = source.repositoryUrl {
                 // Check if this is a Git-based package
                 var packageName = source.name
@@ -63,17 +66,11 @@ class GolangPackageManager: PackageManagerProtocol {
                     gitVersion = rev
                 }
 
-                let versionedPackage = "\(packageName)@\(gitVersion)"
-                _ = try await executeInDirectory(
-                    in: packagePath.path, ["go get \(versionedPackage)"]
-                )
+                goInstallCommand.append("\(packageName)@\(gitVersion)")
             } else {
-                // Standard package installation
-                let versionedPackage = "\(source.name)@\(source.version)"
-                _ = try await executeInDirectory(
-                    in: packagePath.path, ["go get \(versionedPackage)"]
-                )
+                goInstallCommand.append("\(source.name)@\(source.version)")
             }
+            _ = try await executeInDirectory(in: packagePath.path, goInstallCommand)
 
             // If there's a subpath, build the binary
             if let subpath = source.options["subpath"] {

CodeEdit/Features/LSP/Registry/PackageManagers/GolangPackageManager.swift

@@ -130,7 +130,7 @@ enum InstallationMethod: Equatable {
     /// For packages that need to be built from source with custom build steps
     case sourceBuild(source: PackageSource, command: String)
     /// For direct binary downloads
-    case binaryDownload(source: PackageSource, url: String)
+    case binaryDownload(source: PackageSource, url: URL)
     /// For installations that aren't recognized
     case unknown
 

CodeEdit/Features/LSP/Registry/PackageManagers/PackageManagerProtocol.swift

@@ -345,7 +345,7 @@ enum PackageSourceParser {
         let gitReference: GitReference = isCommitHash ? .revision(version) : .tag(version)
 
         // Is this going to be built from source or downloaded
-        let isSourceBuild = if case .none? = entry.source.asset {
+        let isSourceBuild = if entry.source.asset == nil {
             true
         } else {
             false
@@ -390,7 +390,7 @@ enum PackageSourceParser {
             return .unknown
         }
 
-        let downloadURL = "\(repoURL)/releases/download/\(gitTag)/\(fileName)"
+        let downloadURL = URL(string: "\(repoURL)/releases/download/\(gitTag)/\(fileName)")!
         return .binaryDownload(source: pkgSource, url: downloadURL)
     }
 
@@ -399,7 +399,7 @@ enum PackageSourceParser {
         _ entry: RegistryItem
     ) -> InstallationMethod {
         guard let build = entry.source.build,
-              var command = build.getUnixBuildCommand()
+              let command = build.getUnixBuildCommand()
         else {
             return .unknown
         }

CodeEdit/Features/LSP/Registry/PackageManagers/PackageSourceParser.swift

@@ -65,12 +65,7 @@ class PipPackageManager: PackageManagerProtocol {
             }
 
             _ = try await executeInDirectory(in: packagePath.path, installArgs)
-            try updateRequirements(
-                packagePath: packagePath,
-                package: source.name,
-                version: source.version,
-                extras: extras
-            )
+            try await updateRequirements(packagePath: packagePath)
             try await verifyInstallation(packagePath: packagePath, package: source.name)
 
             print("Successfully installed \(source.name)@\(source.version)")
@@ -119,46 +114,35 @@ class PipPackageManager: PackageManagerProtocol {
     }
 
     /// Update the requirements.txt file with the installed package and extras
-    private func updateRequirements(packagePath: URL, package: String, version: String, extras: String? = nil) throws {
+    private func updateRequirements(packagePath: URL) async throws {
+        let pipCommand = getPipCommand(in: packagePath)
         let requirementsPath = packagePath.appendingPathComponent("requirements.txt")
-        var requirementsContent = ""
 
-        if FileManager.default.fileExists(atPath: requirementsPath.path),
-           let existingContent = try? String(contentsOf: requirementsPath, encoding: .utf8) {
-            requirementsContent = existingContent
-        }
-
-        var packageLine = "\(package)"
-        if let extras = extras {
-            packageLine += "[\(extras)]"
-        }
-        packageLine += "==\(version)"
-
-        let packagePattern = "^\\s*\(package)(\\[.*\\])?\\s*==.*$"
-        if let range = requirementsContent.range(of: packagePattern, options: .regularExpression) {
-            // Replace existing version
-            requirementsContent.replaceSubrange(range, with: packageLine)
-        } else {
-            // Add package to requirements
-            if !requirementsContent.isEmpty && !requirementsContent.hasSuffix("\n") {
-                requirementsContent += "\n"
-            }
-            requirementsContent += "\(packageLine)\n"
-        }
+        let freezeOutput = try await executeInDirectory(
+            in: packagePath.path,
+            ["\(pipCommand)", "freeze"]
+        )
 
+        let requirementsContent = freezeOutput.joined(separator: "\n") + "\n"
         try requirementsContent.write(to: requirementsPath, atomically: true, encoding: .utf8)
     }
 
     private func verifyInstallation(packagePath: URL, package: String) async throws {
         let pipCommand = getPipCommand(in: packagePath)
         let output = try await executeInDirectory(
-            in: packagePath.path, ["\(pipCommand) list"]
+            in: packagePath.path, ["\(pipCommand)", "list", "--format=freeze"]
         )
 
-        // Check if the package appears in pip list
-        let packagePattern = "^\(package)\\s+.*$"
-        let packageFound = output.contains { line in
-            line.range(of: packagePattern, options: .regularExpression) != nil
+        // Normalize package names for comparison
+        let normalizedPackageHyphen = package.replacingOccurrences(of: "_", with: "-").lowercased()
+        let normalizedPackageUnderscore = package.replacingOccurrences(of: "-", with: "_").lowercased()
+
+        // Check if the package name appears in requirements.txt
+        let installedPackages = output.map { line in
+            line.lowercased().split(separator: "=").first?.trimmingCharacters(in: .whitespacesAndNewlines)
+        }
+        let packageFound = installedPackages.contains { installedPackage in
+            installedPackage == normalizedPackageHyphen || installedPackage == normalizedPackageUnderscore
         }
 
         guard packageFound else {

CodeEdit/Features/LSP/Registry/PackageManagers/PipPackageManager.swift

@@ -54,7 +54,11 @@ enum RegistryItemTemplateParser {
         // Find all {{ ... }} patterns
         let pattern = "\\{\\{([^\\}]+)\\}\\}"
         let regex = try NSRegularExpression(pattern: pattern, options: [])
-        let matches = regex.matches(in: template, options: [], range: NSRange(location: 0, length: template.utf16.count))
+        let matches = regex.matches(
+            in: template,
+            options: [],
+            range: NSRange(location: 0, length: template.utf16.count)
+        )
 
         // Process matches in reverse order to not invalidate ranges
         for match in matches.reversed() {
@@ -72,8 +76,8 @@ enum RegistryItemTemplateParser {
             // Apply filters
             var processedValue = value
             if components.count > 1 {
-                for i in 1..<components.count {
-                    let filterString = components[i].trimmingCharacters(in: .whitespaces)
+                for item in 1..<components.count {
+                    let filterString = components[item].trimmingCharacters(in: .whitespaces)
                     let filter = try Filter.parse(filterString)
                     processedValue = filter.apply(to: processedValue)
                 }