2024-01-04 09:49:03 -07:00
|
|
|
package main
|
|
|
|
|
|
|
|
// This file is our main entrypoint, and build point for AllPac
|
2024-01-04 13:08:32 -07:00
|
|
|
|
|
|
|
import (
|
|
|
|
"fmt"
|
|
|
|
"os"
|
Major update 4
This should be the final code update before we start testing things.
I think all the code is now in place to have the program function, barring any bugs in my code.
So, with that said, here's the changelog:
global changes:
```
- implement logger.go across the whole program
```
changes to main.go:
```
- add an import for strings
- implement the roughed in handling functions
```
changes to logger.go:
```
- create this little helper package to just handle all our logging nice and gracefully
```
changes to all_updater.go:
```
- basically completely redone. Accomplishes the same thing, just in a different, more efficient way.
```
changes to aur.go:
```
- add a function to clear the AllPac build cache for aur
```
changes to install.go:
```
- removed a duplicate function, set install.go to call the right one
```
changes to pacman.go:
```
- removed GetVersionFromPacman function (it shouldn't be here, it should be in search.go)
```
changes to search.go:
```
- add functions for getting info from, and parsing output from Snap, Pacman, Flatpak, and aur
```
2024-01-04 19:17:43 -07:00
|
|
|
"strings"
|
2024-01-04 13:08:32 -07:00
|
|
|
"pixelridgesoftworks.com/AllPac/pkg/packagemanager"
|
2024-01-04 20:12:26 -07:00
|
|
|
"pixelridgesoftworks.com/AllPac/pkg/logger"
|
2024-01-07 16:04:27 -07:00
|
|
|
"pixelridgesoftworks.com/AllPac/pkg/toolcheck"
|
2024-01-04 20:12:26 -07:00
|
|
|
"path/filepath"
|
2024-01-05 12:53:27 -07:00
|
|
|
"regexp"
|
2024-01-04 13:08:32 -07:00
|
|
|
)
|
|
|
|
|
|
|
|
func main() {
|
2024-01-07 16:04:27 -07:00
|
|
|
// 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)
|
|
|
|
}
|
|
|
|
|
2024-01-04 13:08:32 -07:00
|
|
|
if len(os.Args) < 2 {
|
2024-01-07 16:04:27 -07:00
|
|
|
fmt.Println("Expected 'update', 'install', 'uninstall', 'search', 'rebuild', 'clean-aur', or 'toolcheck' subcommands")
|
2024-01-04 13:08:32 -07:00
|
|
|
os.Exit(1)
|
|
|
|
}
|
|
|
|
|
2024-01-07 17:30:30 -07:00
|
|
|
command := os.Args[1]
|
|
|
|
args := os.Args[2:]
|
|
|
|
|
|
|
|
switch command {
|
|
|
|
case "update":
|
|
|
|
handleUpdate(args)
|
|
|
|
case "install":
|
|
|
|
handleInstall(args)
|
|
|
|
case "uninstall":
|
|
|
|
handleUninstall(args)
|
|
|
|
case "search":
|
|
|
|
handleSearch(args)
|
|
|
|
case "rebuild":
|
|
|
|
handleRebuild(args)
|
|
|
|
case "clean-aur":
|
|
|
|
handleCleanAur(args)
|
|
|
|
case "toolcheck":
|
|
|
|
handleToolCheck(args)
|
2024-01-07 18:30:16 -07:00
|
|
|
case "version":
|
|
|
|
handleVersion(args)
|
2024-01-08 14:30:51 -07:00
|
|
|
case "repair":
|
|
|
|
handleRepair(args)
|
2024-01-07 17:30:30 -07:00
|
|
|
default:
|
|
|
|
fmt.Printf("Unknown subcommand: %s\n", command)
|
2024-01-04 13:08:32 -07:00
|
|
|
os.Exit(1)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2024-01-07 17:30:30 -07:00
|
|
|
func handleUpdate(args []string) {
|
|
|
|
if len(args) == 0 {
|
2024-01-07 18:36:13 -07:00
|
|
|
fmt.Println("You must specify an update option: 'everything', 'snaps', 'aur', 'arch', 'flats', or a specific package name.")
|
2024-01-07 17:30:30 -07:00
|
|
|
return
|
2024-01-07 16:04:27 -07:00
|
|
|
}
|
2024-01-04 13:08:32 -07:00
|
|
|
|
2024-01-08 14:30:51 -07:00
|
|
|
_, err := packagemanager.ReadPackageList()
|
|
|
|
if err != nil {
|
|
|
|
fmt.Printf("error reading package list. Consider running 'allpac repair': %v", err)
|
|
|
|
}
|
|
|
|
|
2024-01-07 16:04:27 -07:00
|
|
|
updateFuncs := map[string]func() error{
|
|
|
|
"everything": packagemanager.UpdateAllPackages,
|
2024-01-07 18:36:13 -07:00
|
|
|
"snaps": func() error { return packagemanager.UpdateSnapPackages() },
|
2024-01-07 16:04:27 -07:00
|
|
|
"aur": func() error { return packagemanager.UpdateAURPackages() },
|
|
|
|
"arch": func() error { return packagemanager.UpdatePacmanPackages() },
|
|
|
|
"flats": func() error { return packagemanager.UpdateFlatpakPackages() },
|
2024-01-04 13:08:32 -07:00
|
|
|
}
|
2024-01-07 16:04:27 -07:00
|
|
|
|
2024-01-07 17:30:30 -07:00
|
|
|
updateOption := args[0]
|
|
|
|
if updateFunc, ok := updateFuncs[updateOption]; ok {
|
|
|
|
err := updateFunc()
|
|
|
|
handleUpdateError(updateOption, err)
|
|
|
|
} else {
|
|
|
|
err := packagemanager.UpdatePackageByName(updateOption)
|
|
|
|
handleUpdateError(updateOption, err)
|
2024-01-07 16:04:27 -07:00
|
|
|
}
|
2024-01-04 13:08:32 -07:00
|
|
|
}
|
|
|
|
|
Major update 4
This should be the final code update before we start testing things.
I think all the code is now in place to have the program function, barring any bugs in my code.
So, with that said, here's the changelog:
global changes:
```
- implement logger.go across the whole program
```
changes to main.go:
```
- add an import for strings
- implement the roughed in handling functions
```
changes to logger.go:
```
- create this little helper package to just handle all our logging nice and gracefully
```
changes to all_updater.go:
```
- basically completely redone. Accomplishes the same thing, just in a different, more efficient way.
```
changes to aur.go:
```
- add a function to clear the AllPac build cache for aur
```
changes to install.go:
```
- removed a duplicate function, set install.go to call the right one
```
changes to pacman.go:
```
- removed GetVersionFromPacman function (it shouldn't be here, it should be in search.go)
```
changes to search.go:
```
- add functions for getting info from, and parsing output from Snap, Pacman, Flatpak, and aur
```
2024-01-04 19:17:43 -07:00
|
|
|
// handles the install command for packages
|
2024-01-07 17:30:30 -07:00
|
|
|
func handleInstall(args []string) {
|
|
|
|
if len(args) == 0 {
|
Major update 4
This should be the final code update before we start testing things.
I think all the code is now in place to have the program function, barring any bugs in my code.
So, with that said, here's the changelog:
global changes:
```
- implement logger.go across the whole program
```
changes to main.go:
```
- add an import for strings
- implement the roughed in handling functions
```
changes to logger.go:
```
- create this little helper package to just handle all our logging nice and gracefully
```
changes to all_updater.go:
```
- basically completely redone. Accomplishes the same thing, just in a different, more efficient way.
```
changes to aur.go:
```
- add a function to clear the AllPac build cache for aur
```
changes to install.go:
```
- removed a duplicate function, set install.go to call the right one
```
changes to pacman.go:
```
- removed GetVersionFromPacman function (it shouldn't be here, it should be in search.go)
```
changes to search.go:
```
- add functions for getting info from, and parsing output from Snap, Pacman, Flatpak, and aur
```
2024-01-04 19:17:43 -07:00
|
|
|
fmt.Println("You must specify at least one package name.")
|
|
|
|
return
|
|
|
|
}
|
|
|
|
|
2024-01-07 17:30:30 -07:00
|
|
|
// Join the args to form a single string, then split by comma
|
|
|
|
packagesInput := strings.Join(args, " ")
|
|
|
|
packageNames := strings.Split(packagesInput, ",")
|
|
|
|
|
|
|
|
// Trim whitespace from each package name
|
|
|
|
for i, pkg := range packageNames {
|
|
|
|
packageNames[i] = strings.TrimSpace(pkg)
|
|
|
|
}
|
|
|
|
|
|
|
|
searchResults, err := packagemanager.SearchAllSources(packageNames)
|
Major update 4
This should be the final code update before we start testing things.
I think all the code is now in place to have the program function, barring any bugs in my code.
So, with that said, here's the changelog:
global changes:
```
- implement logger.go across the whole program
```
changes to main.go:
```
- add an import for strings
- implement the roughed in handling functions
```
changes to logger.go:
```
- create this little helper package to just handle all our logging nice and gracefully
```
changes to all_updater.go:
```
- basically completely redone. Accomplishes the same thing, just in a different, more efficient way.
```
changes to aur.go:
```
- add a function to clear the AllPac build cache for aur
```
changes to install.go:
```
- removed a duplicate function, set install.go to call the right one
```
changes to pacman.go:
```
- removed GetVersionFromPacman function (it shouldn't be here, it should be in search.go)
```
changes to search.go:
```
- add functions for getting info from, and parsing output from Snap, Pacman, Flatpak, and aur
```
2024-01-04 19:17:43 -07:00
|
|
|
if err != nil {
|
|
|
|
fmt.Printf("Error searching for packages: %v\n", err)
|
|
|
|
return
|
|
|
|
}
|
|
|
|
|
2024-01-07 16:04:27 -07:00
|
|
|
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
|
|
|
|
},
|
|
|
|
}
|
|
|
|
|
Major update 4
This should be the final code update before we start testing things.
I think all the code is now in place to have the program function, barring any bugs in my code.
So, with that said, here's the changelog:
global changes:
```
- implement logger.go across the whole program
```
changes to main.go:
```
- add an import for strings
- implement the roughed in handling functions
```
changes to logger.go:
```
- create this little helper package to just handle all our logging nice and gracefully
```
changes to all_updater.go:
```
- basically completely redone. Accomplishes the same thing, just in a different, more efficient way.
```
changes to aur.go:
```
- add a function to clear the AllPac build cache for aur
```
changes to install.go:
```
- removed a duplicate function, set install.go to call the right one
```
changes to pacman.go:
```
- removed GetVersionFromPacman function (it shouldn't be here, it should be in search.go)
```
changes to search.go:
```
- add functions for getting info from, and parsing output from Snap, Pacman, Flatpak, and aur
```
2024-01-04 19:17:43 -07:00
|
|
|
for _, result := range searchResults {
|
|
|
|
fmt.Printf("Searching for package: %s\n", result.PackageName)
|
2024-01-05 12:53:27 -07:00
|
|
|
exactMatches := filterExactMatches(result.PackageName, result.Results)
|
|
|
|
|
|
|
|
if len(exactMatches) == 0 {
|
|
|
|
fmt.Println("No exact matches found for package.")
|
Major update 4
This should be the final code update before we start testing things.
I think all the code is now in place to have the program function, barring any bugs in my code.
So, with that said, here's the changelog:
global changes:
```
- implement logger.go across the whole program
```
changes to main.go:
```
- add an import for strings
- implement the roughed in handling functions
```
changes to logger.go:
```
- create this little helper package to just handle all our logging nice and gracefully
```
changes to all_updater.go:
```
- basically completely redone. Accomplishes the same thing, just in a different, more efficient way.
```
changes to aur.go:
```
- add a function to clear the AllPac build cache for aur
```
changes to install.go:
```
- removed a duplicate function, set install.go to call the right one
```
changes to pacman.go:
```
- removed GetVersionFromPacman function (it shouldn't be here, it should be in search.go)
```
changes to search.go:
```
- add functions for getting info from, and parsing output from Snap, Pacman, Flatpak, and aur
```
2024-01-04 19:17:43 -07:00
|
|
|
continue
|
|
|
|
}
|
|
|
|
|
2024-01-07 16:04:27 -07:00
|
|
|
selectedSource := getSelectedSource(exactMatches)
|
|
|
|
if selectedSource == "" {
|
|
|
|
continue
|
Major update 4
This should be the final code update before we start testing things.
I think all the code is now in place to have the program function, barring any bugs in my code.
So, with that said, here's the changelog:
global changes:
```
- implement logger.go across the whole program
```
changes to main.go:
```
- add an import for strings
- implement the roughed in handling functions
```
changes to logger.go:
```
- create this little helper package to just handle all our logging nice and gracefully
```
changes to all_updater.go:
```
- basically completely redone. Accomplishes the same thing, just in a different, more efficient way.
```
changes to aur.go:
```
- add a function to clear the AllPac build cache for aur
```
changes to install.go:
```
- removed a duplicate function, set install.go to call the right one
```
changes to pacman.go:
```
- removed GetVersionFromPacman function (it shouldn't be here, it should be in search.go)
```
changes to search.go:
```
- add functions for getting info from, and parsing output from Snap, Pacman, Flatpak, and aur
```
2024-01-04 19:17:43 -07:00
|
|
|
}
|
|
|
|
|
2024-01-07 17:30:30 -07:00
|
|
|
// Display the actual package name that will be installed
|
|
|
|
fmt.Printf("Available package(s) for installation from %s:\n", selectedSource)
|
|
|
|
for _, match := range exactMatches {
|
|
|
|
if match.Source == selectedSource {
|
|
|
|
for _, pkg := range match.Results {
|
|
|
|
fmt.Println(pkg)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
Major update 4
This should be the final code update before we start testing things.
I think all the code is now in place to have the program function, barring any bugs in my code.
So, with that said, here's the changelog:
global changes:
```
- implement logger.go across the whole program
```
changes to main.go:
```
- add an import for strings
- implement the roughed in handling functions
```
changes to logger.go:
```
- create this little helper package to just handle all our logging nice and gracefully
```
changes to all_updater.go:
```
- basically completely redone. Accomplishes the same thing, just in a different, more efficient way.
```
changes to aur.go:
```
- add a function to clear the AllPac build cache for aur
```
changes to install.go:
```
- removed a duplicate function, set install.go to call the right one
```
changes to pacman.go:
```
- removed GetVersionFromPacman function (it shouldn't be here, it should be in search.go)
```
changes to search.go:
```
- add functions for getting info from, and parsing output from Snap, Pacman, Flatpak, and aur
```
2024-01-04 19:17:43 -07:00
|
|
|
fmt.Printf("Installing %s from %s...\n", result.PackageName, selectedSource)
|
2024-01-07 16:04:27 -07:00
|
|
|
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 {
|
Major update 4
This should be the final code update before we start testing things.
I think all the code is now in place to have the program function, barring any bugs in my code.
So, with that said, here's the changelog:
global changes:
```
- implement logger.go across the whole program
```
changes to main.go:
```
- add an import for strings
- implement the roughed in handling functions
```
changes to logger.go:
```
- create this little helper package to just handle all our logging nice and gracefully
```
changes to all_updater.go:
```
- basically completely redone. Accomplishes the same thing, just in a different, more efficient way.
```
changes to aur.go:
```
- add a function to clear the AllPac build cache for aur
```
changes to install.go:
```
- removed a duplicate function, set install.go to call the right one
```
changes to pacman.go:
```
- removed GetVersionFromPacman function (it shouldn't be here, it should be in search.go)
```
changes to search.go:
```
- add functions for getting info from, and parsing output from Snap, Pacman, Flatpak, and aur
```
2024-01-04 19:17:43 -07:00
|
|
|
fmt.Printf("Unknown source for package %s\n", result.PackageName)
|
|
|
|
}
|
2024-01-07 16:04:27 -07:00
|
|
|
}
|
|
|
|
}
|
Major update 4
This should be the final code update before we start testing things.
I think all the code is now in place to have the program function, barring any bugs in my code.
So, with that said, here's the changelog:
global changes:
```
- implement logger.go across the whole program
```
changes to main.go:
```
- add an import for strings
- implement the roughed in handling functions
```
changes to logger.go:
```
- create this little helper package to just handle all our logging nice and gracefully
```
changes to all_updater.go:
```
- basically completely redone. Accomplishes the same thing, just in a different, more efficient way.
```
changes to aur.go:
```
- add a function to clear the AllPac build cache for aur
```
changes to install.go:
```
- removed a duplicate function, set install.go to call the right one
```
changes to pacman.go:
```
- removed GetVersionFromPacman function (it shouldn't be here, it should be in search.go)
```
changes to search.go:
```
- add functions for getting info from, and parsing output from Snap, Pacman, Flatpak, and aur
```
2024-01-04 19:17:43 -07:00
|
|
|
|
2024-01-07 16:04:27 -07:00
|
|
|
func getSelectedSource(exactMatches []packagemanager.SourceResult) string {
|
|
|
|
if len(exactMatches) == 1 {
|
|
|
|
return exactMatches[0].Source
|
Major update 4
This should be the final code update before we start testing things.
I think all the code is now in place to have the program function, barring any bugs in my code.
So, with that said, here's the changelog:
global changes:
```
- implement logger.go across the whole program
```
changes to main.go:
```
- add an import for strings
- implement the roughed in handling functions
```
changes to logger.go:
```
- create this little helper package to just handle all our logging nice and gracefully
```
changes to all_updater.go:
```
- basically completely redone. Accomplishes the same thing, just in a different, more efficient way.
```
changes to aur.go:
```
- add a function to clear the AllPac build cache for aur
```
changes to install.go:
```
- removed a duplicate function, set install.go to call the right one
```
changes to pacman.go:
```
- removed GetVersionFromPacman function (it shouldn't be here, it should be in search.go)
```
changes to search.go:
```
- add functions for getting info from, and parsing output from Snap, Pacman, Flatpak, and aur
```
2024-01-04 19:17:43 -07:00
|
|
|
}
|
2024-01-07 16:04:27 -07:00
|
|
|
|
|
|
|
sourceIndex := promptUserForSource(exactMatches)
|
|
|
|
if sourceIndex < 0 || sourceIndex >= len(exactMatches) {
|
|
|
|
fmt.Println("Invalid selection. Skipping package.")
|
|
|
|
return ""
|
|
|
|
}
|
|
|
|
return exactMatches[sourceIndex].Source
|
2024-01-04 13:08:32 -07:00
|
|
|
}
|
|
|
|
|
2024-01-05 12:53:27 -07:00
|
|
|
// 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
|
|
|
|
for _, sourceResult := range sourceResults {
|
|
|
|
var filteredResults []string
|
|
|
|
for _, result := range sourceResult.Results {
|
|
|
|
if isExactMatch(packageName, result) {
|
|
|
|
filteredResults = append(filteredResults, result)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if len(filteredResults) > 0 {
|
|
|
|
exactMatches = append(exactMatches, packagemanager.SourceResult{Source: sourceResult.Source, Results: filteredResults})
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return exactMatches
|
|
|
|
}
|
|
|
|
|
|
|
|
// checks if the given result string is an exact match for the package name
|
|
|
|
func isExactMatch(packageName, result string) bool {
|
|
|
|
pattern := fmt.Sprintf("^%s(?:-\\d+|\\-dev)?(?: - [^ ]+)?", regexp.QuoteMeta(packageName))
|
|
|
|
matched, _ := regexp.MatchString(pattern, result)
|
|
|
|
return matched
|
|
|
|
}
|
|
|
|
|
2024-01-07 16:04:27 -07:00
|
|
|
// handles the uninstall command for packages
|
2024-01-07 17:30:30 -07:00
|
|
|
func handleUninstall(args []string) {
|
|
|
|
if len(args) == 0 {
|
Major update 4
This should be the final code update before we start testing things.
I think all the code is now in place to have the program function, barring any bugs in my code.
So, with that said, here's the changelog:
global changes:
```
- implement logger.go across the whole program
```
changes to main.go:
```
- add an import for strings
- implement the roughed in handling functions
```
changes to logger.go:
```
- create this little helper package to just handle all our logging nice and gracefully
```
changes to all_updater.go:
```
- basically completely redone. Accomplishes the same thing, just in a different, more efficient way.
```
changes to aur.go:
```
- add a function to clear the AllPac build cache for aur
```
changes to install.go:
```
- removed a duplicate function, set install.go to call the right one
```
changes to pacman.go:
```
- removed GetVersionFromPacman function (it shouldn't be here, it should be in search.go)
```
changes to search.go:
```
- add functions for getting info from, and parsing output from Snap, Pacman, Flatpak, and aur
```
2024-01-04 19:17:43 -07:00
|
|
|
fmt.Println("You must specify at least one package name.")
|
|
|
|
return
|
|
|
|
}
|
|
|
|
|
2024-01-07 17:30:30 -07:00
|
|
|
// Join the args to form a single string, then split by comma
|
|
|
|
packagesInput := strings.Join(args, " ")
|
|
|
|
packageNames := strings.Split(packagesInput, ",")
|
|
|
|
|
|
|
|
// Trim whitespace from each package name
|
|
|
|
for i, pkg := range packageNames {
|
|
|
|
packageNames[i] = strings.TrimSpace(pkg)
|
|
|
|
}
|
Major update 4
This should be the final code update before we start testing things.
I think all the code is now in place to have the program function, barring any bugs in my code.
So, with that said, here's the changelog:
global changes:
```
- implement logger.go across the whole program
```
changes to main.go:
```
- add an import for strings
- implement the roughed in handling functions
```
changes to logger.go:
```
- create this little helper package to just handle all our logging nice and gracefully
```
changes to all_updater.go:
```
- basically completely redone. Accomplishes the same thing, just in a different, more efficient way.
```
changes to aur.go:
```
- add a function to clear the AllPac build cache for aur
```
changes to install.go:
```
- removed a duplicate function, set install.go to call the right one
```
changes to pacman.go:
```
- removed GetVersionFromPacman function (it shouldn't be here, it should be in search.go)
```
changes to search.go:
```
- add functions for getting info from, and parsing output from Snap, Pacman, Flatpak, and aur
```
2024-01-04 19:17:43 -07:00
|
|
|
|
|
|
|
// Call the function to uninstall the packages
|
2024-01-07 17:30:30 -07:00
|
|
|
err := packagemanager.UninstallPackages(packageNames)
|
Major update 4
This should be the final code update before we start testing things.
I think all the code is now in place to have the program function, barring any bugs in my code.
So, with that said, here's the changelog:
global changes:
```
- implement logger.go across the whole program
```
changes to main.go:
```
- add an import for strings
- implement the roughed in handling functions
```
changes to logger.go:
```
- create this little helper package to just handle all our logging nice and gracefully
```
changes to all_updater.go:
```
- basically completely redone. Accomplishes the same thing, just in a different, more efficient way.
```
changes to aur.go:
```
- add a function to clear the AllPac build cache for aur
```
changes to install.go:
```
- removed a duplicate function, set install.go to call the right one
```
changes to pacman.go:
```
- removed GetVersionFromPacman function (it shouldn't be here, it should be in search.go)
```
changes to search.go:
```
- add functions for getting info from, and parsing output from Snap, Pacman, Flatpak, and aur
```
2024-01-04 19:17:43 -07:00
|
|
|
if err != nil {
|
|
|
|
fmt.Printf("Error uninstalling packages: %v\n", err)
|
|
|
|
} else {
|
|
|
|
fmt.Println("Requested packages uninstalled successfully.")
|
|
|
|
}
|
2024-01-04 13:08:32 -07:00
|
|
|
}
|
|
|
|
|
2024-01-07 16:04:27 -07:00
|
|
|
// handles the search command for packages across different package managers
|
2024-01-07 17:30:30 -07:00
|
|
|
func handleSearch(args []string) {
|
2024-01-04 20:12:26 -07:00
|
|
|
if len(args) < 1 {
|
Major update 4
This should be the final code update before we start testing things.
I think all the code is now in place to have the program function, barring any bugs in my code.
So, with that said, here's the changelog:
global changes:
```
- implement logger.go across the whole program
```
changes to main.go:
```
- add an import for strings
- implement the roughed in handling functions
```
changes to logger.go:
```
- create this little helper package to just handle all our logging nice and gracefully
```
changes to all_updater.go:
```
- basically completely redone. Accomplishes the same thing, just in a different, more efficient way.
```
changes to aur.go:
```
- add a function to clear the AllPac build cache for aur
```
changes to install.go:
```
- removed a duplicate function, set install.go to call the right one
```
changes to pacman.go:
```
- removed GetVersionFromPacman function (it shouldn't be here, it should be in search.go)
```
changes to search.go:
```
- add functions for getting info from, and parsing output from Snap, Pacman, Flatpak, and aur
```
2024-01-04 19:17:43 -07:00
|
|
|
fmt.Println("You must specify a package name.")
|
|
|
|
return
|
|
|
|
}
|
|
|
|
|
2024-01-04 20:12:26 -07:00
|
|
|
packageName := args[0]
|
|
|
|
|
2024-01-07 16:04:27 -07:00
|
|
|
// Search across all sources
|
|
|
|
searchResults, err := packagemanager.SearchAllSources([]string{packageName})
|
Major update 4
This should be the final code update before we start testing things.
I think all the code is now in place to have the program function, barring any bugs in my code.
So, with that said, here's the changelog:
global changes:
```
- implement logger.go across the whole program
```
changes to main.go:
```
- add an import for strings
- implement the roughed in handling functions
```
changes to logger.go:
```
- create this little helper package to just handle all our logging nice and gracefully
```
changes to all_updater.go:
```
- basically completely redone. Accomplishes the same thing, just in a different, more efficient way.
```
changes to aur.go:
```
- add a function to clear the AllPac build cache for aur
```
changes to install.go:
```
- removed a duplicate function, set install.go to call the right one
```
changes to pacman.go:
```
- removed GetVersionFromPacman function (it shouldn't be here, it should be in search.go)
```
changes to search.go:
```
- add functions for getting info from, and parsing output from Snap, Pacman, Flatpak, and aur
```
2024-01-04 19:17:43 -07:00
|
|
|
if err != nil {
|
2024-01-07 16:04:27 -07:00
|
|
|
logger.Errorf("Error searching for package %s: %v", packageName, err)
|
|
|
|
return
|
Major update 4
This should be the final code update before we start testing things.
I think all the code is now in place to have the program function, barring any bugs in my code.
So, with that said, here's the changelog:
global changes:
```
- implement logger.go across the whole program
```
changes to main.go:
```
- add an import for strings
- implement the roughed in handling functions
```
changes to logger.go:
```
- create this little helper package to just handle all our logging nice and gracefully
```
changes to all_updater.go:
```
- basically completely redone. Accomplishes the same thing, just in a different, more efficient way.
```
changes to aur.go:
```
- add a function to clear the AllPac build cache for aur
```
changes to install.go:
```
- removed a duplicate function, set install.go to call the right one
```
changes to pacman.go:
```
- removed GetVersionFromPacman function (it shouldn't be here, it should be in search.go)
```
changes to search.go:
```
- add functions for getting info from, and parsing output from Snap, Pacman, Flatpak, and aur
```
2024-01-04 19:17:43 -07:00
|
|
|
}
|
|
|
|
|
2024-01-07 16:04:27 -07:00
|
|
|
if len(searchResults) == 0 {
|
|
|
|
fmt.Println("No results found for package:", packageName)
|
|
|
|
return
|
Major update 4
This should be the final code update before we start testing things.
I think all the code is now in place to have the program function, barring any bugs in my code.
So, with that said, here's the changelog:
global changes:
```
- implement logger.go across the whole program
```
changes to main.go:
```
- add an import for strings
- implement the roughed in handling functions
```
changes to logger.go:
```
- create this little helper package to just handle all our logging nice and gracefully
```
changes to all_updater.go:
```
- basically completely redone. Accomplishes the same thing, just in a different, more efficient way.
```
changes to aur.go:
```
- add a function to clear the AllPac build cache for aur
```
changes to install.go:
```
- removed a duplicate function, set install.go to call the right one
```
changes to pacman.go:
```
- removed GetVersionFromPacman function (it shouldn't be here, it should be in search.go)
```
changes to search.go:
```
- add functions for getting info from, and parsing output from Snap, Pacman, Flatpak, and aur
```
2024-01-04 19:17:43 -07:00
|
|
|
}
|
|
|
|
|
2024-01-07 16:04:27 -07:00
|
|
|
// 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
|
Major update 4
This should be the final code update before we start testing things.
I think all the code is now in place to have the program function, barring any bugs in my code.
So, with that said, here's the changelog:
global changes:
```
- implement logger.go across the whole program
```
changes to main.go:
```
- add an import for strings
- implement the roughed in handling functions
```
changes to logger.go:
```
- create this little helper package to just handle all our logging nice and gracefully
```
changes to all_updater.go:
```
- basically completely redone. Accomplishes the same thing, just in a different, more efficient way.
```
changes to aur.go:
```
- add a function to clear the AllPac build cache for aur
```
changes to install.go:
```
- removed a duplicate function, set install.go to call the right one
```
changes to pacman.go:
```
- removed GetVersionFromPacman function (it shouldn't be here, it should be in search.go)
```
changes to search.go:
```
- add functions for getting info from, and parsing output from Snap, Pacman, Flatpak, and aur
```
2024-01-04 19:17:43 -07:00
|
|
|
}
|
|
|
|
|
2024-01-07 16:04:27 -07:00
|
|
|
for _, sourceResult := range result.Results {
|
|
|
|
fmt.Printf("%s Results from %s:\n", result.PackageName, sourceResult.Source)
|
|
|
|
for _, res := range sourceResult.Results {
|
|
|
|
fmt.Println(res)
|
|
|
|
}
|
Major update 4
This should be the final code update before we start testing things.
I think all the code is now in place to have the program function, barring any bugs in my code.
So, with that said, here's the changelog:
global changes:
```
- implement logger.go across the whole program
```
changes to main.go:
```
- add an import for strings
- implement the roughed in handling functions
```
changes to logger.go:
```
- create this little helper package to just handle all our logging nice and gracefully
```
changes to all_updater.go:
```
- basically completely redone. Accomplishes the same thing, just in a different, more efficient way.
```
changes to aur.go:
```
- add a function to clear the AllPac build cache for aur
```
changes to install.go:
```
- removed a duplicate function, set install.go to call the right one
```
changes to pacman.go:
```
- removed GetVersionFromPacman function (it shouldn't be here, it should be in search.go)
```
changes to search.go:
```
- add functions for getting info from, and parsing output from Snap, Pacman, Flatpak, and aur
```
2024-01-04 19:17:43 -07:00
|
|
|
}
|
|
|
|
}
|
2024-01-04 13:08:32 -07:00
|
|
|
}
|
|
|
|
|
2024-01-07 16:04:27 -07:00
|
|
|
// handles the rebuild command for an AUR package
|
2024-01-07 17:30:30 -07:00
|
|
|
func handleRebuild(args []string) {
|
|
|
|
if len(args) == 0 {
|
|
|
|
fmt.Println("You must specify the name of an AUR package to rebuild.")
|
|
|
|
return
|
|
|
|
}
|
Major update 4
This should be the final code update before we start testing things.
I think all the code is now in place to have the program function, barring any bugs in my code.
So, with that said, here's the changelog:
global changes:
```
- implement logger.go across the whole program
```
changes to main.go:
```
- add an import for strings
- implement the roughed in handling functions
```
changes to logger.go:
```
- create this little helper package to just handle all our logging nice and gracefully
```
changes to all_updater.go:
```
- basically completely redone. Accomplishes the same thing, just in a different, more efficient way.
```
changes to aur.go:
```
- add a function to clear the AllPac build cache for aur
```
changes to install.go:
```
- removed a duplicate function, set install.go to call the right one
```
changes to pacman.go:
```
- removed GetVersionFromPacman function (it shouldn't be here, it should be in search.go)
```
changes to search.go:
```
- add functions for getting info from, and parsing output from Snap, Pacman, Flatpak, and aur
```
2024-01-04 19:17:43 -07:00
|
|
|
|
2024-01-07 17:30:30 -07:00
|
|
|
packageName := args[0]
|
Major update 4
This should be the final code update before we start testing things.
I think all the code is now in place to have the program function, barring any bugs in my code.
So, with that said, here's the changelog:
global changes:
```
- implement logger.go across the whole program
```
changes to main.go:
```
- add an import for strings
- implement the roughed in handling functions
```
changes to logger.go:
```
- create this little helper package to just handle all our logging nice and gracefully
```
changes to all_updater.go:
```
- basically completely redone. Accomplishes the same thing, just in a different, more efficient way.
```
changes to aur.go:
```
- add a function to clear the AllPac build cache for aur
```
changes to install.go:
```
- removed a duplicate function, set install.go to call the right one
```
changes to pacman.go:
```
- removed GetVersionFromPacman function (it shouldn't be here, it should be in search.go)
```
changes to search.go:
```
- add functions for getting info from, and parsing output from Snap, Pacman, Flatpak, and aur
```
2024-01-04 19:17:43 -07:00
|
|
|
|
2024-01-07 17:30:30 -07:00
|
|
|
pkgList, err := packagemanager.ReadPackageList()
|
|
|
|
if err != nil {
|
|
|
|
fmt.Printf("Error reading package list: %v\n", err)
|
|
|
|
return
|
|
|
|
}
|
|
|
|
|
|
|
|
if _, exists := pkgList[packageName]; !exists {
|
|
|
|
fmt.Printf("Package %s is not managed by AllPac or not installed.\n", packageName)
|
Major update 4
This should be the final code update before we start testing things.
I think all the code is now in place to have the program function, barring any bugs in my code.
So, with that said, here's the changelog:
global changes:
```
- implement logger.go across the whole program
```
changes to main.go:
```
- add an import for strings
- implement the roughed in handling functions
```
changes to logger.go:
```
- create this little helper package to just handle all our logging nice and gracefully
```
changes to all_updater.go:
```
- basically completely redone. Accomplishes the same thing, just in a different, more efficient way.
```
changes to aur.go:
```
- add a function to clear the AllPac build cache for aur
```
changes to install.go:
```
- removed a duplicate function, set install.go to call the right one
```
changes to pacman.go:
```
- removed GetVersionFromPacman function (it shouldn't be here, it should be in search.go)
```
changes to search.go:
```
- add functions for getting info from, and parsing output from Snap, Pacman, Flatpak, and aur
```
2024-01-04 19:17:43 -07:00
|
|
|
return
|
|
|
|
}
|
|
|
|
|
2024-01-07 17:30:30 -07:00
|
|
|
cacheDir := filepath.Join(os.Getenv("HOME"), ".allpac", "cache", packageName)
|
|
|
|
if err := os.RemoveAll(cacheDir); err != nil {
|
|
|
|
fmt.Printf("Error removing old build directory: %v\n", err)
|
|
|
|
return
|
|
|
|
}
|
|
|
|
|
|
|
|
err = packagemanager.RebuildAndReinstallAURPackage(packageName)
|
Major update 4
This should be the final code update before we start testing things.
I think all the code is now in place to have the program function, barring any bugs in my code.
So, with that said, here's the changelog:
global changes:
```
- implement logger.go across the whole program
```
changes to main.go:
```
- add an import for strings
- implement the roughed in handling functions
```
changes to logger.go:
```
- create this little helper package to just handle all our logging nice and gracefully
```
changes to all_updater.go:
```
- basically completely redone. Accomplishes the same thing, just in a different, more efficient way.
```
changes to aur.go:
```
- add a function to clear the AllPac build cache for aur
```
changes to install.go:
```
- removed a duplicate function, set install.go to call the right one
```
changes to pacman.go:
```
- removed GetVersionFromPacman function (it shouldn't be here, it should be in search.go)
```
changes to search.go:
```
- add functions for getting info from, and parsing output from Snap, Pacman, Flatpak, and aur
```
2024-01-04 19:17:43 -07:00
|
|
|
if err != nil {
|
2024-01-07 17:30:30 -07:00
|
|
|
fmt.Printf("Error rebuilding package %s: %v\n", packageName, err)
|
Major update 4
This should be the final code update before we start testing things.
I think all the code is now in place to have the program function, barring any bugs in my code.
So, with that said, here's the changelog:
global changes:
```
- implement logger.go across the whole program
```
changes to main.go:
```
- add an import for strings
- implement the roughed in handling functions
```
changes to logger.go:
```
- create this little helper package to just handle all our logging nice and gracefully
```
changes to all_updater.go:
```
- basically completely redone. Accomplishes the same thing, just in a different, more efficient way.
```
changes to aur.go:
```
- add a function to clear the AllPac build cache for aur
```
changes to install.go:
```
- removed a duplicate function, set install.go to call the right one
```
changes to pacman.go:
```
- removed GetVersionFromPacman function (it shouldn't be here, it should be in search.go)
```
changes to search.go:
```
- add functions for getting info from, and parsing output from Snap, Pacman, Flatpak, and aur
```
2024-01-04 19:17:43 -07:00
|
|
|
} else {
|
2024-01-07 17:30:30 -07:00
|
|
|
fmt.Printf("Package %s rebuilt and reinstalled successfully.\n", packageName)
|
Major update 4
This should be the final code update before we start testing things.
I think all the code is now in place to have the program function, barring any bugs in my code.
So, with that said, here's the changelog:
global changes:
```
- implement logger.go across the whole program
```
changes to main.go:
```
- add an import for strings
- implement the roughed in handling functions
```
changes to logger.go:
```
- create this little helper package to just handle all our logging nice and gracefully
```
changes to all_updater.go:
```
- basically completely redone. Accomplishes the same thing, just in a different, more efficient way.
```
changes to aur.go:
```
- add a function to clear the AllPac build cache for aur
```
changes to install.go:
```
- removed a duplicate function, set install.go to call the right one
```
changes to pacman.go:
```
- removed GetVersionFromPacman function (it shouldn't be here, it should be in search.go)
```
changes to search.go:
```
- add functions for getting info from, and parsing output from Snap, Pacman, Flatpak, and aur
```
2024-01-04 19:17:43 -07:00
|
|
|
}
|
2024-01-04 13:08:32 -07:00
|
|
|
}
|
|
|
|
|
2024-01-07 16:04:27 -07:00
|
|
|
// handles the cleaning of AUR cache
|
2024-01-07 17:30:30 -07:00
|
|
|
func handleCleanAur(args []string) {
|
Major update 4
This should be the final code update before we start testing things.
I think all the code is now in place to have the program function, barring any bugs in my code.
So, with that said, here's the changelog:
global changes:
```
- implement logger.go across the whole program
```
changes to main.go:
```
- add an import for strings
- implement the roughed in handling functions
```
changes to logger.go:
```
- create this little helper package to just handle all our logging nice and gracefully
```
changes to all_updater.go:
```
- basically completely redone. Accomplishes the same thing, just in a different, more efficient way.
```
changes to aur.go:
```
- add a function to clear the AllPac build cache for aur
```
changes to install.go:
```
- removed a duplicate function, set install.go to call the right one
```
changes to pacman.go:
```
- removed GetVersionFromPacman function (it shouldn't be here, it should be in search.go)
```
changes to search.go:
```
- add functions for getting info from, and parsing output from Snap, Pacman, Flatpak, and aur
```
2024-01-04 19:17:43 -07:00
|
|
|
// Call the function to clear the AUR cache
|
|
|
|
err := packagemanager.ClearAllPacCache()
|
|
|
|
if err != nil {
|
2024-01-07 16:04:27 -07:00
|
|
|
fmt.Printf("Error clearing AllPac cache: %v\n", err)
|
Major update 4
This should be the final code update before we start testing things.
I think all the code is now in place to have the program function, barring any bugs in my code.
So, with that said, here's the changelog:
global changes:
```
- implement logger.go across the whole program
```
changes to main.go:
```
- add an import for strings
- implement the roughed in handling functions
```
changes to logger.go:
```
- create this little helper package to just handle all our logging nice and gracefully
```
changes to all_updater.go:
```
- basically completely redone. Accomplishes the same thing, just in a different, more efficient way.
```
changes to aur.go:
```
- add a function to clear the AllPac build cache for aur
```
changes to install.go:
```
- removed a duplicate function, set install.go to call the right one
```
changes to pacman.go:
```
- removed GetVersionFromPacman function (it shouldn't be here, it should be in search.go)
```
changes to search.go:
```
- add functions for getting info from, and parsing output from Snap, Pacman, Flatpak, and aur
```
2024-01-04 19:17:43 -07:00
|
|
|
return
|
|
|
|
}
|
|
|
|
|
2024-01-07 16:04:27 -07:00
|
|
|
fmt.Println("AllPac cache cleared successfully.")
|
Major update 4
This should be the final code update before we start testing things.
I think all the code is now in place to have the program function, barring any bugs in my code.
So, with that said, here's the changelog:
global changes:
```
- implement logger.go across the whole program
```
changes to main.go:
```
- add an import for strings
- implement the roughed in handling functions
```
changes to logger.go:
```
- create this little helper package to just handle all our logging nice and gracefully
```
changes to all_updater.go:
```
- basically completely redone. Accomplishes the same thing, just in a different, more efficient way.
```
changes to aur.go:
```
- add a function to clear the AllPac build cache for aur
```
changes to install.go:
```
- removed a duplicate function, set install.go to call the right one
```
changes to pacman.go:
```
- removed GetVersionFromPacman function (it shouldn't be here, it should be in search.go)
```
changes to search.go:
```
- add functions for getting info from, and parsing output from Snap, Pacman, Flatpak, and aur
```
2024-01-04 19:17:43 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
// prompts the user to select a source for installation
|
|
|
|
func promptUserForSource(sources []packagemanager.SourceResult) int {
|
|
|
|
for i, source := range sources {
|
|
|
|
fmt.Printf("%d: %s\n", i, source.Source)
|
|
|
|
}
|
|
|
|
fmt.Print("Select the source number to install from: ")
|
|
|
|
var choice int
|
|
|
|
fmt.Scan(&choice)
|
|
|
|
return choice
|
2024-01-04 13:08:32 -07:00
|
|
|
}
|
2024-01-07 16:04:27 -07:00
|
|
|
|
2024-01-07 17:30:30 -07:00
|
|
|
func handleToolCheck(args []string) {
|
2024-01-07 16:04:27 -07:00
|
|
|
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)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|