From 3131f71460e23c91d41e9abe83a4f8163444580d Mon Sep 17 00:00:00 2001 From: VetheonGames Date: Sun, 7 Jan 2024 16:04:27 -0700 Subject: [PATCH] Minor Update 2 changes to main.go: ``` - refactor basically the entire file to use less switch statements and more slices - implement the toolcheck functionality - add the toolcheck command ``` changes to snap.go: ``` - fix the exec.Command call to use args properly - fix up snap.go to handle the pkg.list properly ``` --- cmd/main.go | 259 ++++++++++++++++++------------------- pkg/packagemanager/snap.go | 28 +++- 2 files changed, 150 insertions(+), 137 deletions(-) diff --git a/cmd/main.go b/cmd/main.go index 08846f8..7db06c8 100644 --- a/cmd/main.go +++ b/cmd/main.go @@ -9,75 +9,73 @@ import ( "strings" "pixelridgesoftworks.com/AllPac/pkg/packagemanager" "pixelridgesoftworks.com/AllPac/pkg/logger" + "pixelridgesoftworks.com/AllPac/pkg/toolcheck" "path/filepath" "regexp" ) func main() { - // Initialize the logger - logFilePath := filepath.Join(os.Getenv("HOME"), ".allpac", "logs", "allpac.log") - if err := logger.Init(logFilePath); err != nil { - // If logger initialization fails, you can choose to exit the program or use the default logger - logger.Errorf("Failed to initialize logger: %v", err) - } - // Define flags for different commands - updateCmd := flag.NewFlagSet("update", flag.ExitOnError) - installCmd := flag.NewFlagSet("install", flag.ExitOnError) - uninstallCmd := flag.NewFlagSet("uninstall", flag.ExitOnError) - searchCmd := flag.NewFlagSet("search", flag.ExitOnError) - aurRebuildCmd := flag.NewFlagSet("rebuild", flag.ExitOnError) - aurCleanCmd := flag.NewFlagSet("clean-aur", flag.ExitOnError) + // Initialize the logger + logFilePath := filepath.Join(os.Getenv("HOME"), ".allpac", "logs", "allpac.log") + if err := logger.Init(logFilePath); err != nil { + logger.Errorf("Failed to initialize logger: %v", err) + } + + // Define flag sets for different commands + commandHandlers := map[string]func(*flag.FlagSet){ + "update": handleUpdate, + "install": handleInstall, + "uninstall": handleUninstall, + "search": func(cmd *flag.FlagSet) { handleSearch(cmd, os.Args[2:]) }, + "rebuild": handleRebuild, + "clean-aur": handleCleanAur, + "toolcheck": handleToolCheck, + } if len(os.Args) < 2 { - fmt.Println("Expected 'update', 'install', 'uninstall', 'search', 'rebuild', or 'clean-aur' subcommands") + fmt.Println("Expected 'update', 'install', 'uninstall', 'search', 'rebuild', 'clean-aur', or 'toolcheck' subcommands") os.Exit(1) } - switch os.Args[1] { - case "update": - handleUpdate(updateCmd) - case "install": - handleInstall(installCmd) - case "uninstall": - handleUninstall(uninstallCmd) - case "search": - handleSearch(searchCmd, os.Args[2:]) - case "rebuild": - handleRebuild(aurRebuildCmd) - case "clean-aur": - handleCleanAur(aurCleanCmd) - default: + if handler, ok := commandHandlers[os.Args[1]]; ok { + cmd := flag.NewFlagSet(os.Args[1], flag.ExitOnError) + handler(cmd) + } else { fmt.Printf("Unknown subcommand: %s\n", os.Args[1]) os.Exit(1) } } func handleUpdate(cmd *flag.FlagSet) { - everythingFlag := cmd.Bool("everything", false, "Update all packages on the system") - snapFlag := cmd.Bool("snap", false, "Update all Snap packages") - aurFlag := cmd.Bool("aur", false, "Update all AUR packages") - archFlag := cmd.Bool("arch", false, "Update all Arch packages") - flatsFlag := cmd.Bool("flats", false, "Update all Flatpak packages") + updateFlags := map[string]*bool{ + "everything": cmd.Bool("everything", false, "Update all packages on the system"), + "snap": cmd.Bool("snap", false, "Update all Snap packages"), + "aur": cmd.Bool("aur", false, "Update all AUR packages"), + "arch": cmd.Bool("arch", false, "Update all Arch packages"), + "flats": cmd.Bool("flats", false, "Update all Flatpak packages"), + } cmd.Parse(os.Args[2:]) - if *everythingFlag { - // Call function to update all packages - packagemanager.UpdateAllPackages() - } else if *snapFlag { - // Call function to update Snap packages - packagemanager.UpdateSnapPackages() - } else if *aurFlag { - // Call function to update AUR packages - packagemanager.UpdateAURPackages() - } else if *archFlag { - // Call function to update Arch packages - packagemanager.UpdatePacmanPackages() - } else if *flatsFlag { - // Call function to update Flatpak packages - packagemanager.UpdateFlatpakPackages() - } else { - fmt.Println("No update option specified or unrecognized option") + updateFuncs := map[string]func() error{ + "everything": packagemanager.UpdateAllPackages, + "snap": func() error { return packagemanager.UpdateSnapPackages() }, + "aur": func() error { return packagemanager.UpdateAURPackages() }, + "arch": func() error { return packagemanager.UpdatePacmanPackages() }, + "flats": func() error { return packagemanager.UpdateFlatpakPackages() }, } + + for flagName, flagValue := range updateFlags { + if *flagValue { + if updateFunc, ok := updateFuncs[flagName]; ok { + if err := updateFunc(); err != nil { + fmt.Printf("Error occurred during '%s' update: %v\n", flagName, err) + } + return + } + } + } + + fmt.Println("No update option specified or unrecognized option") } // handles the install command for packages @@ -98,10 +96,18 @@ func handleInstall(cmd *flag.FlagSet) { return } + installFuncs := map[string]func(string) error{ + "Pacman": packagemanager.InstallPackagePacman, + "Snap": packagemanager.InstallPackageSnap, + "Flatpak": packagemanager.InstallPackageFlatpak, + "AUR": func(pkgName string) error { + _, err := packagemanager.CloneAndInstallFromAUR(fmt.Sprintf("https://aur.archlinux.org/%s.git", pkgName), false) + return err + }, + } + for _, result := range searchResults { fmt.Printf("Searching for package: %s\n", result.PackageName) - - // Filter for exact matches exactMatches := filterExactMatches(result.PackageName, result.Results) if len(exactMatches) == 0 { @@ -109,44 +115,37 @@ func handleInstall(cmd *flag.FlagSet) { continue } - var selectedSource string - if len(exactMatches) == 1 { - // Only one source available, use it automatically - selectedSource = exactMatches[0].Source - } else { - // Multiple sources available, prompt the user to choose - sourceIndex := promptUserForSource(exactMatches) - if sourceIndex < 0 || sourceIndex >= len(exactMatches) { - fmt.Println("Invalid selection. Skipping package.") - continue - } - selectedSource = exactMatches[sourceIndex].Source - } - - fmt.Printf("Installing %s from %s...\n", result.PackageName, selectedSource) - - switch selectedSource { - case "Pacman": - err = packagemanager.InstallPackagePacman(result.PackageName) - case "Snap": - err = packagemanager.InstallPackageSnap(result.PackageName) - case "Flatpak": - err = packagemanager.InstallPackageFlatpak(result.PackageName) - case "AUR": - _, err = packagemanager.CloneAndInstallFromAUR(fmt.Sprintf("https://aur.archlinux.org/%s.git", result.PackageName), false) - default: - fmt.Printf("Unknown source for package %s\n", result.PackageName) + selectedSource := getSelectedSource(exactMatches) + if selectedSource == "" { continue } - if err != nil { - fmt.Printf("Error installing package %s from %s: %v\n", result.PackageName, selectedSource, err) + fmt.Printf("Installing %s from %s...\n", result.PackageName, selectedSource) + if installFunc, ok := installFuncs[selectedSource]; ok { + if err := installFunc(result.PackageName); err != nil { + fmt.Printf("Error installing package %s from %s: %v\n", result.PackageName, selectedSource, err) + } else { + fmt.Printf("Package %s installed successfully from %s.\n", result.PackageName, selectedSource) + } } else { - fmt.Printf("Package %s installed successfully from %s.\n", result.PackageName, selectedSource) + fmt.Printf("Unknown source for package %s\n", result.PackageName) } } } +func getSelectedSource(exactMatches []packagemanager.SourceResult) string { + if len(exactMatches) == 1 { + return exactMatches[0].Source + } + + sourceIndex := promptUserForSource(exactMatches) + if sourceIndex < 0 || sourceIndex >= len(exactMatches) { + fmt.Println("Invalid selection. Skipping package.") + return "" + } + return exactMatches[sourceIndex].Source +} + // filters the search results to include only those with an exact match func filterExactMatches(packageName string, sourceResults []packagemanager.SourceResult) []packagemanager.SourceResult { var exactMatches []packagemanager.SourceResult @@ -171,22 +170,18 @@ func isExactMatch(packageName, result string) bool { return matched } -// handleUninstall handles the uninstall command for packages +// handles the uninstall command for packages func handleUninstall(cmd *flag.FlagSet) { - // Define a flag for accepting multiple package names packageNames := cmd.String("packages", "", "Comma-separated list of packages to uninstall") - // Parse the command line arguments cmd.Parse(os.Args[2:]) - // Check if the package names were provided if *packageNames == "" { fmt.Println("You must specify at least one package name.") cmd.Usage() return } - // Split the package names and convert to a slice packages := strings.Split(*packageNames, ",") // Call the function to uninstall the packages @@ -198,81 +193,56 @@ func handleUninstall(cmd *flag.FlagSet) { } } -// handleSearch handles the search command for packages across different package managers +// handles the search command for packages across different package managers func handleSearch(cmd *flag.FlagSet, args []string) { - // Check if the package name was provided if len(args) < 1 { fmt.Println("You must specify a package name.") cmd.Usage() return } - // The package name is the first argument packageName := args[0] - // Search in Pacman - pacmanResults, err := packagemanager.SearchPacman(packageName) + // Search across all sources + searchResults, err := packagemanager.SearchAllSources([]string{packageName}) if err != nil { - logger.Errorf("Error searching in Pacman: %v", err) - } else if len(pacmanResults) == 0 { - fmt.Println("Pacman: No results found") - } else { - fmt.Println("Pacman Results:") - for _, result := range pacmanResults { - fmt.Println(result) - } + logger.Errorf("Error searching for package %s: %v", packageName, err) + return } - // Search in Snap - snapResults, err := packagemanager.SearchSnap(packageName) - if err != nil { - fmt.Printf("Error searching in Snap: %v\n", err) - } else { - fmt.Println("Snap Results:") - for _, result := range snapResults { - fmt.Println(result) - } + if len(searchResults) == 0 { + fmt.Println("No results found for package:", packageName) + return } - // Search in Flatpak - flatpakResults, err := packagemanager.SearchFlatpak(packageName) - if err != nil { - fmt.Printf("Error searching in Flatpak: %v\n", err) - } else { - fmt.Println("Flatpak Results:") - for _, result := range flatpakResults { - fmt.Println(result) + // Iterate over the search results and print them + for _, result := range searchResults { + if len(result.Results) == 0 { + fmt.Printf("%s: No results found\n", result.PackageName) + continue } - } - // Search in AUR - aurResults, err := packagemanager.SearchAUR(packageName) - if err != nil { - fmt.Printf("Error searching in AUR: %v\n", err) - } else { - fmt.Println("AUR Results:") - for _, result := range aurResults { - fmt.Printf("%s - %s\n", result.Name, result.Version) + for _, sourceResult := range result.Results { + fmt.Printf("%s Results from %s:\n", result.PackageName, sourceResult.Source) + for _, res := range sourceResult.Results { + fmt.Println(res) + } } } } -// handleRebuild handles the rebuild command for an AUR package +// handles the rebuild command for an AUR package func handleRebuild(cmd *flag.FlagSet) { - // Define a flag for the package name packageName := cmd.String("package", "", "Name of the AUR package to rebuild") - // Parse the command line arguments cmd.Parse(os.Args[2:]) - // Check if the package name was provided if *packageName == "" { fmt.Println("You must specify a package name.") cmd.Usage() return } - // Call the function to rebuild and reinstall the AUR package err := packagemanager.RebuildAndReinstallAURPackage(*packageName) if err != nil { fmt.Printf("Error rebuilding package %s: %v\n", *packageName, err) @@ -281,7 +251,7 @@ func handleRebuild(cmd *flag.FlagSet) { } } -// handleCleanAur handles the cleaning of AUR cache +// handles the cleaning of AUR cache func handleCleanAur(cmd *flag.FlagSet) { // Parse the command flags if needed cmd.Parse(os.Args[2:]) @@ -289,11 +259,11 @@ func handleCleanAur(cmd *flag.FlagSet) { // Call the function to clear the AUR cache err := packagemanager.ClearAllPacCache() if err != nil { - fmt.Printf("Error clearing AUR cache: %v\n", err) + fmt.Printf("Error clearing AllPac cache: %v\n", err) return } - fmt.Println("AUR cache cleared successfully.") + fmt.Println("AllPac cache cleared successfully.") } // prompts the user to select a source for installation @@ -306,3 +276,24 @@ func promptUserForSource(sources []packagemanager.SourceResult) int { fmt.Scan(&choice) return choice } + +func handleToolCheck(cmd *flag.FlagSet) { + checks := []struct { + Name string + Func func() error + }{ + {"Pacman", toolcheck.EnsurePacman}, + {"Base-devel", toolcheck.EnsureBaseDevel}, + {"Git", toolcheck.EnsureGit}, + {"Snap", toolcheck.EnsureSnap}, + {"Flatpak", toolcheck.EnsureFlatpak}, + } + + for _, check := range checks { + if err := check.Func(); err != nil { + fmt.Printf("%s check failed: %v\n", check.Name, err) + } else { + fmt.Printf("%s is installed and available.\n", check.Name) + } + } +} diff --git a/pkg/packagemanager/snap.go b/pkg/packagemanager/snap.go index 33e544f..29a3eed 100644 --- a/pkg/packagemanager/snap.go +++ b/pkg/packagemanager/snap.go @@ -31,8 +31,8 @@ func UpdateSnapPackages(packageNames ...string) error { if len(packageNames) == 0 { cmd = exec.Command("sudo", "snap", "refresh") } else { - args := append([]string{"refresh"}, packageNames...) - cmd = exec.Command("sudo", "snap", args...) + args := append([]string{"snap", "refresh"}, packageNames...) + cmd = exec.Command("sudo", args...) } if output, err := cmd.CombinedOutput(); err != nil { @@ -58,11 +58,33 @@ func UpdateSnapPackages(packageNames ...string) error { // UninstallSnapPackage uninstalls a specified Snap package func UninstallSnapPackage(packageName string) error { + // Read the current package list + pkgList, err := ReadPackageList() + if err != nil { + logger.Errorf("An error has occurred while reading the package list: %v", err) + return err + } + + // Check if the package is managed by AllPac + if _, exists := pkgList[packageName]; !exists { + logger.Infof("Package %s not found in the package list, may not be managed by AllPac", packageName) + return nil + } + + // Uninstalling the Snap package cmd := exec.Command("sudo", "snap", "remove", packageName) if output, err := cmd.CombinedOutput(); err != nil { - logger.Errorf("error uninstalling Snap package: %s, %v", string(output), err) + logger.Errorf("error uninstalling Snap package: %s, %v", string(output), err) return fmt.Errorf("error uninstalling Snap package: %s, %v", string(output), err) } + + // Remove the package from the list after successful uninstallation + if err := RemovePackageFromList(packageName); err != nil { + logger.Errorf("An error has occurred while removing the package from the list: %v", err) + return err + } + + logger.Infof("Package %s successfully uninstalled and removed from the package list", packageName) return nil }