mirror of
https://github.com/Jguer/yay
synced 2024-10-01 13:53:32 +00:00
fix(cmdArgs): deglobal cmd args
This commit is contained in:
jguer
parent
93719d488c
commit
7a32ffdd37
12
clean.go
12
clean.go
|
|
@ -38,21 +38,21 @@ func removeVCSPackage(pkgs []string) {
|
|||
}
|
||||
|
||||
// CleanDependencies removes all dangling dependencies in system
|
||||
func cleanDependencies(removeOptional bool, alpmHandle *alpm.Handle) error {
|
||||
func cleanDependencies(cmdArgs *settings.Arguments, removeOptional bool, alpmHandle *alpm.Handle) error {
|
||||
hanging, err := hangingPackages(removeOptional, alpmHandle)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
|
||||
if len(hanging) != 0 {
|
||||
return cleanRemove(hanging)
|
||||
return cleanRemove(hanging, cmdArgs)
|
||||
}
|
||||
|
||||
return nil
|
||||
}
|
||||
|
||||
// CleanRemove sends a full removal command to pacman with the pkgName slice
|
||||
func cleanRemove(pkgNames []string) error {
|
||||
func cleanRemove(pkgNames []string, cmdArgs *settings.Arguments) error {
|
||||
if len(pkgNames) == 0 {
|
||||
return nil
|
||||
}
|
||||
|
|
@ -64,11 +64,11 @@ func cleanRemove(pkgNames []string) error {
|
|||
return show(passToPacman(arguments))
|
||||
}
|
||||
|
||||
func syncClean(parser *settings.Arguments, alpmHandle *alpm.Handle) error {
|
||||
func syncClean(cmdArgs *settings.Arguments, alpmHandle *alpm.Handle) error {
|
||||
keepInstalled := false
|
||||
keepCurrent := false
|
||||
|
||||
_, removeAll, _ := parser.GetArg("c", "clean")
|
||||
_, removeAll, _ := cmdArgs.GetArg("c", "clean")
|
||||
|
||||
for _, v := range config.Runtime.PacmanConf.CleanMethod {
|
||||
if v == "KeepInstalled" {
|
||||
|
|
@ -79,7 +79,7 @@ func syncClean(parser *settings.Arguments, alpmHandle *alpm.Handle) error {
|
|||
}
|
||||
|
||||
if config.Runtime.Mode == settings.ModeRepo || config.Runtime.Mode == settings.ModeAny {
|
||||
if err := show(passToPacman(parser)); err != nil {
|
||||
if err := show(passToPacman(cmdArgs)); err != nil {
|
||||
return err
|
||||
}
|
||||
}
|
||||
|
|
|
|||
74
cmd.go
74
cmd.go
|
|
@ -16,8 +16,6 @@ import (
|
|||
"github.com/Jguer/yay/v10/pkg/text"
|
||||
)
|
||||
|
||||
var cmdArgs = settings.MakeArguments()
|
||||
|
||||
func usage() {
|
||||
fmt.Println(`Usage:
|
||||
yay
|
||||
|
|
@ -139,9 +137,9 @@ getpkgbuild specific options:
|
|||
-f --force Force download for existing ABS packages`)
|
||||
}
|
||||
|
||||
func handleCmd(alpmHandle *alpm.Handle) error {
|
||||
func handleCmd(alpmHandle *alpm.Handle, cmdArgs *settings.Arguments) error {
|
||||
if cmdArgs.ExistsArg("h", "help") {
|
||||
return handleHelp()
|
||||
return handleHelp(cmdArgs)
|
||||
}
|
||||
|
||||
if config.SudoLoop && cmdArgs.NeedRoot(config.Runtime) {
|
||||
|
|
@ -157,34 +155,34 @@ func handleCmd(alpmHandle *alpm.Handle) error {
|
|||
case "F", "files":
|
||||
return show(passToPacman(cmdArgs))
|
||||
case "Q", "query":
|
||||
return handleQuery(alpmHandle)
|
||||
return handleQuery(alpmHandle, cmdArgs)
|
||||
case "R", "remove":
|
||||
return handleRemove()
|
||||
return handleRemove(cmdArgs)
|
||||
case "S", "sync":
|
||||
return handleSync(alpmHandle)
|
||||
return handleSync(alpmHandle, cmdArgs)
|
||||
case "T", "deptest":
|
||||
return show(passToPacman(cmdArgs))
|
||||
case "U", "upgrade":
|
||||
return show(passToPacman(cmdArgs))
|
||||
case "G", "getpkgbuild":
|
||||
return handleGetpkgbuild(alpmHandle)
|
||||
return handleGetpkgbuild(alpmHandle, cmdArgs)
|
||||
case "P", "show":
|
||||
return handlePrint(alpmHandle)
|
||||
return handlePrint(alpmHandle, cmdArgs)
|
||||
case "Y", "--yay":
|
||||
return handleYay(alpmHandle)
|
||||
return handleYay(alpmHandle, cmdArgs)
|
||||
}
|
||||
|
||||
return fmt.Errorf(gotext.Get("unhandled operation"))
|
||||
}
|
||||
|
||||
func handleQuery(alpmHandle *alpm.Handle) error {
|
||||
func handleQuery(alpmHandle *alpm.Handle, cmdArgs *settings.Arguments) error {
|
||||
if cmdArgs.ExistsArg("u", "upgrades") {
|
||||
return printUpdateList(cmdArgs, alpmHandle)
|
||||
return printUpdateList(cmdArgs, alpmHandle, cmdArgs.ExistsDouble("u", "sysupgrade"))
|
||||
}
|
||||
return show(passToPacman(cmdArgs))
|
||||
}
|
||||
|
||||
func handleHelp() error {
|
||||
func handleHelp(cmdArgs *settings.Arguments) error {
|
||||
if cmdArgs.Op == "Y" || cmdArgs.Op == "yay" {
|
||||
usage()
|
||||
return nil
|
||||
|
|
@ -196,7 +194,7 @@ func handleVersion() {
|
|||
fmt.Printf("yay v%s - libalpm v%s\n", yayVersion, alpm.Version())
|
||||
}
|
||||
|
||||
func handlePrint(alpmHandle *alpm.Handle) (err error) {
|
||||
func handlePrint(alpmHandle *alpm.Handle, cmdArgs *settings.Arguments) (err error) {
|
||||
switch {
|
||||
case cmdArgs.ExistsArg("d", "defaultconfig"):
|
||||
tmpConfig := settings.MakeConfig()
|
||||
|
|
@ -205,9 +203,7 @@ func handlePrint(alpmHandle *alpm.Handle) (err error) {
|
|||
case cmdArgs.ExistsArg("g", "currentconfig"):
|
||||
fmt.Printf("%v", config)
|
||||
case cmdArgs.ExistsArg("n", "numberupgrades"):
|
||||
err = printNumberOfUpdates(alpmHandle)
|
||||
case cmdArgs.ExistsArg("u", "upgrades"):
|
||||
err = printUpdateList(cmdArgs, alpmHandle)
|
||||
err = printNumberOfUpdates(alpmHandle, cmdArgs.ExistsDouble("u", "sysupgrade"))
|
||||
case cmdArgs.ExistsArg("w", "news"):
|
||||
double := cmdArgs.ExistsDouble("w", "news")
|
||||
quiet := cmdArgs.ExistsArg("q", "quiet")
|
||||
|
|
@ -224,32 +220,32 @@ func handlePrint(alpmHandle *alpm.Handle) (err error) {
|
|||
return err
|
||||
}
|
||||
|
||||
func handleYay(alpmHandle *alpm.Handle) error {
|
||||
func handleYay(alpmHandle *alpm.Handle, cmdArgs *settings.Arguments) error {
|
||||
if cmdArgs.ExistsArg("gendb") {
|
||||
return createDevelDB(config.Runtime.VCSPath, alpmHandle)
|
||||
}
|
||||
if cmdArgs.ExistsDouble("c") {
|
||||
return cleanDependencies(true, alpmHandle)
|
||||
return cleanDependencies(cmdArgs, true, alpmHandle)
|
||||
}
|
||||
if cmdArgs.ExistsArg("c", "clean") {
|
||||
return cleanDependencies(false, alpmHandle)
|
||||
return cleanDependencies(cmdArgs, false, alpmHandle)
|
||||
}
|
||||
if len(cmdArgs.Targets) > 0 {
|
||||
return handleYogurt(alpmHandle)
|
||||
return handleYogurt(alpmHandle, cmdArgs)
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
func handleGetpkgbuild(alpmHandle *alpm.Handle) error {
|
||||
return getPkgbuilds(cmdArgs.Targets, alpmHandle)
|
||||
func handleGetpkgbuild(alpmHandle *alpm.Handle, cmdArgs *settings.Arguments) error {
|
||||
return getPkgbuilds(cmdArgs.Targets, alpmHandle, cmdArgs.ExistsArg("f", "force"))
|
||||
}
|
||||
|
||||
func handleYogurt(alpmHandle *alpm.Handle) error {
|
||||
func handleYogurt(alpmHandle *alpm.Handle, cmdArgs *settings.Arguments) error {
|
||||
config.SearchMode = numberMenu
|
||||
return displayNumberMenu(cmdArgs.Targets, alpmHandle)
|
||||
return displayNumberMenu(cmdArgs.Targets, alpmHandle, cmdArgs)
|
||||
}
|
||||
|
||||
func handleSync(alpmHandle *alpm.Handle) error {
|
||||
func handleSync(alpmHandle *alpm.Handle, cmdArgs *settings.Arguments) error {
|
||||
targets := cmdArgs.Targets
|
||||
|
||||
if cmdArgs.ExistsArg("s", "search") {
|
||||
|
|
@ -273,13 +269,13 @@ func handleSync(alpmHandle *alpm.Handle) error {
|
|||
return show(passToPacman(cmdArgs))
|
||||
}
|
||||
if cmdArgs.ExistsArg("i", "info") {
|
||||
return syncInfo(targets, alpmHandle)
|
||||
return syncInfo(targets, alpmHandle, cmdArgs)
|
||||
}
|
||||
if cmdArgs.ExistsArg("u", "sysupgrade") {
|
||||
return install(cmdArgs, alpmHandle)
|
||||
return install(cmdArgs, alpmHandle, false)
|
||||
}
|
||||
if len(cmdArgs.Targets) > 0 {
|
||||
return install(cmdArgs, alpmHandle)
|
||||
return install(cmdArgs, alpmHandle, false)
|
||||
}
|
||||
if cmdArgs.ExistsArg("y", "refresh") {
|
||||
return show(passToPacman(cmdArgs))
|
||||
|
|
@ -287,7 +283,7 @@ func handleSync(alpmHandle *alpm.Handle) error {
|
|||
return nil
|
||||
}
|
||||
|
||||
func handleRemove() error {
|
||||
func handleRemove(cmdArgs *settings.Arguments) error {
|
||||
err := show(passToPacman(cmdArgs))
|
||||
if err == nil {
|
||||
removeVCSPackage(cmdArgs.Targets)
|
||||
|
|
@ -297,7 +293,7 @@ func handleRemove() error {
|
|||
}
|
||||
|
||||
// NumberMenu presents a CLI for selecting packages to install.
|
||||
func displayNumberMenu(pkgS []string, alpmHandle *alpm.Handle) error {
|
||||
func displayNumberMenu(pkgS []string, alpmHandle *alpm.Handle, cmdArgs *settings.Arguments) error {
|
||||
var (
|
||||
aurErr, repoErr error
|
||||
aq aurQuery
|
||||
|
|
@ -407,20 +403,20 @@ func displayNumberMenu(pkgS []string, alpmHandle *alpm.Handle) error {
|
|||
sudoLoopBackground()
|
||||
}
|
||||
|
||||
return install(arguments, alpmHandle)
|
||||
return install(arguments, alpmHandle, true)
|
||||
}
|
||||
|
||||
func syncList(parser *settings.Arguments, alpmHandle *alpm.Handle) error {
|
||||
func syncList(cmdArgs *settings.Arguments, alpmHandle *alpm.Handle) error {
|
||||
aur := false
|
||||
|
||||
for i := len(parser.Targets) - 1; i >= 0; i-- {
|
||||
if parser.Targets[i] == "aur" && (config.Runtime.Mode == settings.ModeAny || config.Runtime.Mode == settings.ModeAUR) {
|
||||
parser.Targets = append(parser.Targets[:i], parser.Targets[i+1:]...)
|
||||
for i := len(cmdArgs.Targets) - 1; i >= 0; i-- {
|
||||
if cmdArgs.Targets[i] == "aur" && (config.Runtime.Mode == settings.ModeAny || config.Runtime.Mode == settings.ModeAUR) {
|
||||
cmdArgs.Targets = append(cmdArgs.Targets[:i], cmdArgs.Targets[i+1:]...)
|
||||
aur = true
|
||||
}
|
||||
}
|
||||
|
||||
if (config.Runtime.Mode == settings.ModeAny || config.Runtime.Mode == settings.ModeAUR) && (len(parser.Targets) == 0 || aur) {
|
||||
if (config.Runtime.Mode == settings.ModeAny || config.Runtime.Mode == settings.ModeAUR) && (len(cmdArgs.Targets) == 0 || aur) {
|
||||
localDB, err := alpmHandle.LocalDB()
|
||||
if err != nil {
|
||||
return err
|
||||
|
|
@ -451,8 +447,8 @@ func syncList(parser *settings.Arguments, alpmHandle *alpm.Handle) error {
|
|||
}
|
||||
}
|
||||
|
||||
if (config.Runtime.Mode == settings.ModeAny || config.Runtime.Mode == settings.ModeRepo) && (len(parser.Targets) != 0 || !aur) {
|
||||
return show(passToPacman(parser))
|
||||
if (config.Runtime.Mode == settings.ModeAny || config.Runtime.Mode == settings.ModeRepo) && (len(cmdArgs.Targets) != 0 || !aur) {
|
||||
return show(passToPacman(cmdArgs))
|
||||
}
|
||||
|
||||
return nil
|
||||
|
|
|
|||
18
depPool.go
18
depPool.go
|
|
@ -81,7 +81,7 @@ func makeDepPool(alpmHandle *alpm.Handle) (*depPool, error) {
|
|||
}
|
||||
|
||||
// Includes db/ prefixes and group installs
|
||||
func (dp *depPool) ResolveTargets(pkgs []string, alpmHandle *alpm.Handle) error {
|
||||
func (dp *depPool) ResolveTargets(pkgs []string, alpmHandle *alpm.Handle, ignoreProviders bool) error {
|
||||
// RPC requests are slow
|
||||
// Combine as many AUR package requests as possible into a single RPC
|
||||
// call
|
||||
|
|
@ -157,7 +157,7 @@ func (dp *depPool) ResolveTargets(pkgs []string, alpmHandle *alpm.Handle) error
|
|||
}
|
||||
|
||||
if len(aurTargets) > 0 && (config.Runtime.Mode == settings.ModeAny || config.Runtime.Mode == settings.ModeAUR) {
|
||||
return dp.resolveAURPackages(aurTargets, true)
|
||||
return dp.resolveAURPackages(aurTargets, true, ignoreProviders)
|
||||
}
|
||||
|
||||
return nil
|
||||
|
|
@ -267,7 +267,7 @@ func (dp *depPool) cacheAURPackages(_pkgs stringset.StringSet) error {
|
|||
return nil
|
||||
}
|
||||
|
||||
func (dp *depPool) resolveAURPackages(pkgs stringset.StringSet, explicit bool) error {
|
||||
func (dp *depPool) resolveAURPackages(pkgs stringset.StringSet, explicit, ignoreProviders bool) error {
|
||||
newPackages := make(stringset.StringSet)
|
||||
newAURPackages := make(stringset.StringSet)
|
||||
|
||||
|
|
@ -286,7 +286,7 @@ func (dp *depPool) resolveAURPackages(pkgs stringset.StringSet, explicit bool) e
|
|||
continue
|
||||
}
|
||||
|
||||
pkg := dp.findSatisfierAurCache(name)
|
||||
pkg := dp.findSatisfierAurCache(name, ignoreProviders)
|
||||
if pkg == nil {
|
||||
continue
|
||||
}
|
||||
|
|
@ -327,7 +327,7 @@ func (dp *depPool) resolveAURPackages(pkgs stringset.StringSet, explicit bool) e
|
|||
newAURPackages.Set(dep)
|
||||
}
|
||||
|
||||
err = dp.resolveAURPackages(newAURPackages, false)
|
||||
err = dp.resolveAURPackages(newAURPackages, false, ignoreProviders)
|
||||
return err
|
||||
}
|
||||
|
||||
|
|
@ -358,14 +358,14 @@ func (dp *depPool) ResolveRepoDependency(pkg *alpm.Package) {
|
|||
})
|
||||
}
|
||||
|
||||
func getDepPool(pkgs []string, warnings *aurWarnings, alpmHandle *alpm.Handle) (*depPool, error) {
|
||||
func getDepPool(pkgs []string, warnings *aurWarnings, alpmHandle *alpm.Handle, ignoreProviders bool) (*depPool, error) {
|
||||
dp, err := makeDepPool(alpmHandle)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
|
||||
dp.Warnings = warnings
|
||||
err = dp.ResolveTargets(pkgs, alpmHandle)
|
||||
err = dp.ResolveTargets(pkgs, alpmHandle, ignoreProviders)
|
||||
|
||||
return dp, err
|
||||
}
|
||||
|
|
@ -390,7 +390,7 @@ func (dp *depPool) findSatisfierAur(dep string) *rpc.Pkg {
|
|||
// Using Pacman's ways trying to install foo would never give you
|
||||
// a menu.
|
||||
// TODO: maybe intermix repo providers in the menu
|
||||
func (dp *depPool) findSatisfierAurCache(dep string) *rpc.Pkg {
|
||||
func (dp *depPool) findSatisfierAurCache(dep string, ignoreProviders bool) *rpc.Pkg {
|
||||
depName, _, _ := splitDep(dep)
|
||||
seen := make(stringset.StringSet)
|
||||
providerSlice := makeProviders(depName)
|
||||
|
|
@ -401,7 +401,7 @@ func (dp *depPool) findSatisfierAurCache(dep string) *rpc.Pkg {
|
|||
}
|
||||
}
|
||||
|
||||
if cmdArgs.Op == "Y" || cmdArgs.Op == "yay" {
|
||||
if ignoreProviders {
|
||||
for _, pkg := range dp.AurCache {
|
||||
if pkgSatisfies(pkg.Name, pkg.Version, dep) {
|
||||
for _, target := range dp.Targets {
|
||||
|
|
|
|||
10
download.go
10
download.go
|
|
@ -138,7 +138,7 @@ func gitMerge(path, name string) error {
|
|||
return nil
|
||||
}
|
||||
|
||||
func getPkgbuilds(pkgs []string, alpmHandle *alpm.Handle) error {
|
||||
func getPkgbuilds(pkgs []string, alpmHandle *alpm.Handle, force bool) error {
|
||||
missing := false
|
||||
wd, err := os.Getwd()
|
||||
if err != nil {
|
||||
|
|
@ -163,7 +163,7 @@ func getPkgbuilds(pkgs []string, alpmHandle *alpm.Handle) error {
|
|||
}
|
||||
|
||||
if len(repo) > 0 {
|
||||
missing, err = getPkgbuildsfromABS(repo, wd, alpmHandle)
|
||||
missing, err = getPkgbuildsfromABS(repo, wd, alpmHandle, force)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
|
|
@ -182,7 +182,7 @@ func getPkgbuilds(pkgs []string, alpmHandle *alpm.Handle) error {
|
|||
text.Errorln(err)
|
||||
continue
|
||||
default:
|
||||
if cmdArgs.ExistsArg("f", "force") {
|
||||
if force {
|
||||
if err = os.RemoveAll(pkgDest); err != nil {
|
||||
text.Errorln(err)
|
||||
continue
|
||||
|
|
@ -211,7 +211,7 @@ func getPkgbuilds(pkgs []string, alpmHandle *alpm.Handle) error {
|
|||
}
|
||||
|
||||
// GetPkgbuild downloads pkgbuild from the ABS.
|
||||
func getPkgbuildsfromABS(pkgs []string, path string, alpmHandle *alpm.Handle) (bool, error) {
|
||||
func getPkgbuildsfromABS(pkgs []string, path string, alpmHandle *alpm.Handle, force bool) (bool, error) {
|
||||
var wg sync.WaitGroup
|
||||
var mux sync.Mutex
|
||||
var errs multierror.MultiError
|
||||
|
|
@ -270,7 +270,7 @@ func getPkgbuildsfromABS(pkgs []string, path string, alpmHandle *alpm.Handle) (b
|
|||
case err != nil && !os.IsNotExist(err):
|
||||
fmt.Fprintln(os.Stderr, bold(red(smallArrow)), err)
|
||||
continue
|
||||
case os.IsNotExist(err), cmdArgs.ExistsArg("f", "force"):
|
||||
case os.IsNotExist(err), force:
|
||||
if err = os.RemoveAll(filepath.Join(path, name)); err != nil {
|
||||
fmt.Fprintln(os.Stderr, bold(red(smallArrow)), err)
|
||||
continue
|
||||
|
|
|
|||
2
exec.go
2
exec.go
|
|
@ -92,7 +92,7 @@ func passToPacman(args *settings.Arguments) *exec.Cmd {
|
|||
}
|
||||
|
||||
argArr = append(argArr, config.PacmanBin)
|
||||
argArr = append(argArr, cmdArgs.FormatGlobals()...)
|
||||
argArr = append(argArr, args.FormatGlobals()...)
|
||||
argArr = append(argArr, args.FormatArgs()...)
|
||||
if config.NoConfirm {
|
||||
argArr = append(argArr, "--noconfirm")
|
||||
|
|
|
|||
106
install.go
106
install.go
|
|
@ -23,15 +23,15 @@ import (
|
|||
"github.com/Jguer/yay/v10/pkg/text"
|
||||
)
|
||||
|
||||
func asdeps(parser *settings.Arguments, pkgs []string) error {
|
||||
func asdeps(cmdArgs *settings.Arguments, pkgs []string) error {
|
||||
if len(pkgs) == 0 {
|
||||
return nil
|
||||
}
|
||||
|
||||
parser = parser.CopyGlobal()
|
||||
_ = parser.AddArg("D", "asdeps")
|
||||
parser.AddTarget(pkgs...)
|
||||
_, stderr, err := capture(passToPacman(parser))
|
||||
cmdArgs = cmdArgs.CopyGlobal()
|
||||
_ = cmdArgs.AddArg("D", "asdeps")
|
||||
cmdArgs.AddTarget(pkgs...)
|
||||
_, stderr, err := capture(passToPacman(cmdArgs))
|
||||
if err != nil {
|
||||
return fmt.Errorf("%s %s", stderr, err)
|
||||
}
|
||||
|
|
@ -39,15 +39,15 @@ func asdeps(parser *settings.Arguments, pkgs []string) error {
|
|||
return nil
|
||||
}
|
||||
|
||||
func asexp(parser *settings.Arguments, pkgs []string) error {
|
||||
func asexp(cmdArgs *settings.Arguments, pkgs []string) error {
|
||||
if len(pkgs) == 0 {
|
||||
return nil
|
||||
}
|
||||
|
||||
parser = parser.CopyGlobal()
|
||||
_ = parser.AddArg("D", "asexplicit")
|
||||
parser.AddTarget(pkgs...)
|
||||
_, stderr, err := capture(passToPacman(parser))
|
||||
cmdArgs = cmdArgs.CopyGlobal()
|
||||
_ = cmdArgs.AddArg("D", "asexplicit")
|
||||
cmdArgs.AddTarget(pkgs...)
|
||||
_, stderr, err := capture(passToPacman(cmdArgs))
|
||||
if err != nil {
|
||||
return fmt.Errorf("%s %s", stderr, err)
|
||||
}
|
||||
|
|
@ -56,7 +56,7 @@ func asexp(parser *settings.Arguments, pkgs []string) error {
|
|||
}
|
||||
|
||||
// Install handles package installs
|
||||
func install(parser *settings.Arguments, alpmHandle *alpm.Handle) (err error) {
|
||||
func install(cmdArgs *settings.Arguments, alpmHandle *alpm.Handle, ignoreProviders bool) (err error) {
|
||||
var incompatible stringset.StringSet
|
||||
var do *depOrder
|
||||
|
||||
|
|
@ -69,14 +69,14 @@ func install(parser *settings.Arguments, alpmHandle *alpm.Handle) (err error) {
|
|||
|
||||
if config.Runtime.Mode == settings.ModeAny || config.Runtime.Mode == settings.ModeRepo {
|
||||
if config.CombinedUpgrade {
|
||||
if parser.ExistsArg("y", "refresh") {
|
||||
err = earlyRefresh(parser)
|
||||
if cmdArgs.ExistsArg("y", "refresh") {
|
||||
err = earlyRefresh(cmdArgs)
|
||||
if err != nil {
|
||||
return fmt.Errorf(gotext.Get("error refreshing databases"))
|
||||
}
|
||||
}
|
||||
} else if parser.ExistsArg("y", "refresh") || parser.ExistsArg("u", "sysupgrade") || len(parser.Targets) > 0 {
|
||||
err = earlyPacmanCall(parser, alpmHandle)
|
||||
} else if cmdArgs.ExistsArg("y", "refresh") || cmdArgs.ExistsArg("u", "sysupgrade") || len(cmdArgs.Targets) > 0 {
|
||||
err = earlyPacmanCall(cmdArgs, alpmHandle)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
|
|
@ -99,10 +99,10 @@ func install(parser *settings.Arguments, alpmHandle *alpm.Handle) (err error) {
|
|||
remoteNamesCache := stringset.FromSlice(remoteNames)
|
||||
localNamesCache := stringset.FromSlice(localNames)
|
||||
|
||||
requestTargets := parser.Copy().Targets
|
||||
requestTargets := cmdArgs.Copy().Targets
|
||||
|
||||
// create the arguments to pass for the repo install
|
||||
arguments := parser.Copy()
|
||||
arguments := cmdArgs.Copy()
|
||||
arguments.DelArg("asdeps", "asdep")
|
||||
arguments.DelArg("asexplicit", "asexp")
|
||||
arguments.Op = "S"
|
||||
|
|
@ -113,8 +113,8 @@ func install(parser *settings.Arguments, alpmHandle *alpm.Handle) (err error) {
|
|||
}
|
||||
|
||||
// if we are doing -u also request all packages needing update
|
||||
if parser.ExistsArg("u", "sysupgrade") {
|
||||
aurUp, repoUp, err = upList(warnings, alpmHandle)
|
||||
if cmdArgs.ExistsArg("u", "sysupgrade") {
|
||||
aurUp, repoUp, err = upList(warnings, alpmHandle, cmdArgs.ExistsDouble("u", "sysupgrade"))
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
|
|
@ -129,13 +129,13 @@ func install(parser *settings.Arguments, alpmHandle *alpm.Handle) (err error) {
|
|||
for _, up := range repoUp {
|
||||
if !ignore.Get(up.Name) {
|
||||
requestTargets = append(requestTargets, up.Name)
|
||||
parser.AddTarget(up.Name)
|
||||
cmdArgs.AddTarget(up.Name)
|
||||
}
|
||||
}
|
||||
|
||||
for up := range aurUp {
|
||||
requestTargets = append(requestTargets, "aur/"+up)
|
||||
parser.AddTarget("aur/" + up)
|
||||
cmdArgs.AddTarget("aur/" + up)
|
||||
}
|
||||
|
||||
value, _, exists := cmdArgs.GetArg("ignore")
|
||||
|
|
@ -155,14 +155,14 @@ func install(parser *settings.Arguments, alpmHandle *alpm.Handle) (err error) {
|
|||
}
|
||||
}
|
||||
|
||||
targets := stringset.FromSlice(parser.Targets)
|
||||
targets := stringset.FromSlice(cmdArgs.Targets)
|
||||
|
||||
dp, err := getDepPool(requestTargets, warnings, alpmHandle)
|
||||
dp, err := getDepPool(requestTargets, warnings, alpmHandle, ignoreProviders)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
|
||||
if !parser.ExistsDouble("d", "nodeps") {
|
||||
if !cmdArgs.ExistsDouble("d", "nodeps") {
|
||||
err = dp.CheckMissing()
|
||||
if err != nil {
|
||||
return err
|
||||
|
|
@ -171,22 +171,22 @@ func install(parser *settings.Arguments, alpmHandle *alpm.Handle) (err error) {
|
|||
|
||||
if len(dp.Aur) == 0 {
|
||||
if !config.CombinedUpgrade {
|
||||
if parser.ExistsArg("u", "sysupgrade") {
|
||||
if cmdArgs.ExistsArg("u", "sysupgrade") {
|
||||
fmt.Println(gotext.Get(" there is nothing to do"))
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
parser.Op = "S"
|
||||
parser.DelArg("y", "refresh")
|
||||
cmdArgs.Op = "S"
|
||||
cmdArgs.DelArg("y", "refresh")
|
||||
if arguments.ExistsArg("ignore") {
|
||||
if parser.ExistsArg("ignore") {
|
||||
parser.Options["ignore"].Args = append(parser.Options["ignore"].Args, arguments.Options["ignore"].Args...)
|
||||
if cmdArgs.ExistsArg("ignore") {
|
||||
cmdArgs.Options["ignore"].Args = append(cmdArgs.Options["ignore"].Args, arguments.Options["ignore"].Args...)
|
||||
} else {
|
||||
parser.Options["ignore"] = arguments.Options["ignore"]
|
||||
cmdArgs.Options["ignore"] = arguments.Options["ignore"]
|
||||
}
|
||||
}
|
||||
return show(passToPacman(parser))
|
||||
return show(passToPacman(cmdArgs))
|
||||
}
|
||||
|
||||
if len(dp.Aur) > 0 && os.Geteuid() == 0 {
|
||||
|
|
@ -194,7 +194,7 @@ func install(parser *settings.Arguments, alpmHandle *alpm.Handle) (err error) {
|
|||
}
|
||||
|
||||
var conflicts stringset.MapStringSet
|
||||
if !parser.ExistsDouble("d", "nodeps") {
|
||||
if !cmdArgs.ExistsDouble("d", "nodeps") {
|
||||
conflicts, err = dp.CheckConflicts()
|
||||
if err != nil {
|
||||
return err
|
||||
|
|
@ -214,7 +214,7 @@ func install(parser *settings.Arguments, alpmHandle *alpm.Handle) (err error) {
|
|||
arguments.AddTarget(pkg)
|
||||
}
|
||||
|
||||
if len(do.Aur) == 0 && len(arguments.Targets) == 0 && (!parser.ExistsArg("u", "sysupgrade") || config.Runtime.Mode == settings.ModeAUR) {
|
||||
if len(do.Aur) == 0 && len(arguments.Targets) == 0 && (!cmdArgs.ExistsArg("u", "sysupgrade") || config.Runtime.Mode == settings.ModeAUR) {
|
||||
fmt.Println(gotext.Get(" there is nothing to do"))
|
||||
return nil
|
||||
}
|
||||
|
|
@ -360,17 +360,17 @@ func install(parser *settings.Arguments, alpmHandle *alpm.Handle) (err error) {
|
|||
continue
|
||||
}
|
||||
|
||||
if parser.ExistsArg("asdeps", "asdep") && dp.Explicit.Get(pkg.Name()) {
|
||||
if cmdArgs.ExistsArg("asdeps", "asdep") && dp.Explicit.Get(pkg.Name()) {
|
||||
deps = append(deps, pkg.Name())
|
||||
} else if parser.ExistsArg("asexp", "asexplicit") && dp.Explicit.Get(pkg.Name()) {
|
||||
} else if cmdArgs.ExistsArg("asexp", "asexplicit") && dp.Explicit.Get(pkg.Name()) {
|
||||
exp = append(exp, pkg.Name())
|
||||
}
|
||||
}
|
||||
|
||||
if errDeps := asdeps(parser, deps); errDeps != nil {
|
||||
if errDeps := asdeps(cmdArgs, deps); errDeps != nil {
|
||||
return errDeps
|
||||
}
|
||||
if errExp := asexp(parser, exp); errExp != nil {
|
||||
if errExp := asexp(cmdArgs, exp); errExp != nil {
|
||||
return errExp
|
||||
}
|
||||
}
|
||||
|
|
@ -382,7 +382,7 @@ func install(parser *settings.Arguments, alpmHandle *alpm.Handle) (err error) {
|
|||
return err
|
||||
}
|
||||
|
||||
err = buildInstallPkgbuilds(dp, do, srcinfos, parser, incompatible, conflicts, alpmHandle)
|
||||
err = buildInstallPkgbuilds(dp, do, srcinfos, cmdArgs, incompatible, conflicts, alpmHandle)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
|
|
@ -429,11 +429,11 @@ func inRepos(syncDB alpm.DBList, pkg string) bool {
|
|||
return !syncDB.FindGroupPkgs(target.Name).Empty()
|
||||
}
|
||||
|
||||
func earlyPacmanCall(parser *settings.Arguments, alpmHandle *alpm.Handle) error {
|
||||
arguments := parser.Copy()
|
||||
func earlyPacmanCall(cmdArgs *settings.Arguments, alpmHandle *alpm.Handle) error {
|
||||
arguments := cmdArgs.Copy()
|
||||
arguments.Op = "S"
|
||||
targets := parser.Targets
|
||||
parser.ClearTargets()
|
||||
targets := cmdArgs.Targets
|
||||
cmdArgs.ClearTargets()
|
||||
arguments.ClearTargets()
|
||||
|
||||
syncDB, err := alpmHandle.SyncDBs()
|
||||
|
|
@ -449,12 +449,12 @@ func earlyPacmanCall(parser *settings.Arguments, alpmHandle *alpm.Handle) error
|
|||
if inRepos(syncDB, target) {
|
||||
arguments.AddTarget(target)
|
||||
} else {
|
||||
parser.AddTarget(target)
|
||||
cmdArgs.AddTarget(target)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
if parser.ExistsArg("y", "refresh") || parser.ExistsArg("u", "sysupgrade") || len(arguments.Targets) > 0 {
|
||||
if cmdArgs.ExistsArg("y", "refresh") || cmdArgs.ExistsArg("u", "sysupgrade") || len(arguments.Targets) > 0 {
|
||||
err = show(passToPacman(arguments))
|
||||
if err != nil {
|
||||
return errors.New(gotext.Get("error installing repo packages"))
|
||||
|
|
@ -464,9 +464,9 @@ func earlyPacmanCall(parser *settings.Arguments, alpmHandle *alpm.Handle) error
|
|||
return nil
|
||||
}
|
||||
|
||||
func earlyRefresh(parser *settings.Arguments) error {
|
||||
arguments := parser.Copy()
|
||||
parser.DelArg("y", "refresh")
|
||||
func earlyRefresh(cmdArgs *settings.Arguments) error {
|
||||
arguments := cmdArgs.Copy()
|
||||
cmdArgs.DelArg("y", "refresh")
|
||||
arguments.DelArg("u", "sysupgrade")
|
||||
arguments.DelArg("s", "search")
|
||||
arguments.DelArg("i", "info")
|
||||
|
|
@ -950,11 +950,11 @@ func buildInstallPkgbuilds(
|
|||
dp *depPool,
|
||||
do *depOrder,
|
||||
srcinfos map[string]*gosrc.Srcinfo,
|
||||
parser *settings.Arguments,
|
||||
cmdArgs *settings.Arguments,
|
||||
incompatible stringset.StringSet,
|
||||
conflicts stringset.MapStringSet,
|
||||
alpmHandle *alpm.Handle) error {
|
||||
arguments := parser.Copy()
|
||||
arguments := cmdArgs.Copy()
|
||||
arguments.ClearTargets()
|
||||
arguments.Op = "U"
|
||||
arguments.DelArg("confirm")
|
||||
|
|
@ -996,10 +996,10 @@ func buildInstallPkgbuilds(
|
|||
fmt.Fprintln(os.Stderr, err)
|
||||
}
|
||||
|
||||
if errDeps := asdeps(parser, deps); err != nil {
|
||||
if errDeps := asdeps(cmdArgs, deps); err != nil {
|
||||
return errDeps
|
||||
}
|
||||
if errExps := asexp(parser, exp); err != nil {
|
||||
if errExps := asexp(cmdArgs, exp); err != nil {
|
||||
return errExps
|
||||
}
|
||||
|
||||
|
|
@ -1151,9 +1151,9 @@ func buildInstallPkgbuilds(
|
|||
}
|
||||
|
||||
arguments.AddTarget(pkgdest)
|
||||
if parser.ExistsArg("asdeps", "asdep") {
|
||||
if cmdArgs.ExistsArg("asdeps", "asdep") {
|
||||
deps = append(deps, name)
|
||||
} else if parser.ExistsArg("asexplicit", "asexp") {
|
||||
} else if cmdArgs.ExistsArg("asexplicit", "asexp") {
|
||||
exp = append(exp, name)
|
||||
} else if !dp.Explicit.Get(name) && !localNamesCache.Get(name) && !remoteNamesCache.Get(name) {
|
||||
deps = append(deps, name)
|
||||
|
|
|
|||
7
main.go
7
main.go
|
|
@ -74,7 +74,7 @@ func initBuildDir() error {
|
|||
return nil
|
||||
}
|
||||
|
||||
func initAlpm(pacmanConfigPath string) (*alpm.Handle, *pacmanconf.Config, error) {
|
||||
func initAlpm(pacmanConfigPath string, cmdArgs *settings.Arguments) (*alpm.Handle, *pacmanconf.Config, error) {
|
||||
root := "/"
|
||||
if value, _, exists := cmdArgs.GetArg("root", "r"); exists {
|
||||
root = value
|
||||
|
|
@ -180,6 +180,7 @@ func main() {
|
|||
text.Warnln(gotext.Get("Avoid running yay as root/sudo."))
|
||||
}
|
||||
|
||||
cmdArgs := settings.MakeArguments()
|
||||
runtime, err := settings.MakeRuntime()
|
||||
exitOnError(err)
|
||||
config = settings.MakeConfig()
|
||||
|
|
@ -195,8 +196,8 @@ func main() {
|
|||
config.ExpandEnv()
|
||||
exitOnError(initBuildDir())
|
||||
exitOnError(initVCS(runtime.VCSPath))
|
||||
config.Runtime.AlpmHandle, config.Runtime.PacmanConf, err = initAlpm(config.PacmanConf)
|
||||
config.Runtime.AlpmHandle, config.Runtime.PacmanConf, err = initAlpm(config.PacmanConf, cmdArgs)
|
||||
exitOnError(err)
|
||||
exitOnError(handleCmd(config.Runtime.AlpmHandle))
|
||||
exitOnError(handleCmd(config.Runtime.AlpmHandle, cmdArgs))
|
||||
os.Exit(cleanup(config.Runtime.AlpmHandle))
|
||||
}
|
||||
|
|
|
|||
|
|
@ -4,10 +4,12 @@ import (
|
|||
"testing"
|
||||
|
||||
"github.com/stretchr/testify/assert"
|
||||
|
||||
"github.com/Jguer/yay/v10/pkg/settings"
|
||||
)
|
||||
|
||||
func TestInitAlpm(t *testing.T) {
|
||||
alpmHandle, pacmanConf, err := initAlpm("testdata/pacman.conf")
|
||||
alpmHandle, pacmanConf, err := initAlpm("testdata/pacman.conf", settings.MakeArguments())
|
||||
assert.Nil(t, err)
|
||||
assert.NotNil(t, pacmanConf)
|
||||
|
||||
|
|
|
|||
|
|
@ -139,12 +139,12 @@ func TestArguments_CopyGlobal(t *testing.T) {
|
|||
}
|
||||
for _, tt := range tests {
|
||||
t.Run(tt.name, func(t *testing.T) {
|
||||
parser := &Arguments{
|
||||
cmdArgs := &Arguments{
|
||||
Op: tt.fields.Op,
|
||||
Options: tt.fields.Options,
|
||||
Targets: tt.fields.Targets,
|
||||
}
|
||||
got := parser.CopyGlobal()
|
||||
got := cmdArgs.CopyGlobal()
|
||||
assert.NotEqualValues(t, tt.fields.Options, got.Options)
|
||||
assert.NotEqualValues(t, tt.fields.Targets, got.Targets)
|
||||
assert.NotEqual(t, tt.fields.Op, got.Op)
|
||||
|
|
@ -182,13 +182,13 @@ func TestArguments_Copy(t *testing.T) {
|
|||
}
|
||||
for _, tt := range tests {
|
||||
t.Run(tt.name, func(t *testing.T) {
|
||||
parser := &Arguments{
|
||||
cmdArgs := &Arguments{
|
||||
Op: tt.fields.Op,
|
||||
Options: tt.fields.Options,
|
||||
Targets: tt.fields.Targets,
|
||||
}
|
||||
got := parser.Copy()
|
||||
assert.Equal(t, parser, got)
|
||||
got := cmdArgs.Copy()
|
||||
assert.Equal(t, cmdArgs, got)
|
||||
assert.Equal(t, tt.want, got)
|
||||
})
|
||||
}
|
||||
|
|
@ -236,12 +236,12 @@ func TestArguments_FormatArgs(t *testing.T) {
|
|||
}
|
||||
for _, tt := range tests {
|
||||
t.Run(tt.name, func(t *testing.T) {
|
||||
parser := &Arguments{
|
||||
cmdArgs := &Arguments{
|
||||
Op: tt.fields.Op,
|
||||
Options: tt.fields.Options,
|
||||
Targets: tt.fields.Targets,
|
||||
}
|
||||
gotArgs := parser.FormatArgs()
|
||||
gotArgs := cmdArgs.FormatArgs()
|
||||
assert.ElementsMatch(t, gotArgs, tt.wantArgs)
|
||||
})
|
||||
}
|
||||
|
|
@ -281,12 +281,12 @@ func TestArguments_FormatGlobalArgs(t *testing.T) {
|
|||
}
|
||||
for _, tt := range tests {
|
||||
t.Run(tt.name, func(t *testing.T) {
|
||||
parser := &Arguments{
|
||||
cmdArgs := &Arguments{
|
||||
Op: tt.fields.Op,
|
||||
Options: tt.fields.Options,
|
||||
Targets: tt.fields.Targets,
|
||||
}
|
||||
gotArgs := parser.FormatGlobals()
|
||||
gotArgs := cmdArgs.FormatGlobals()
|
||||
assert.ElementsMatch(t, tt.wantArgs, gotArgs)
|
||||
})
|
||||
}
|
||||
|
|
|
|||
22
print.go
22
print.go
|
|
@ -267,7 +267,7 @@ func printDownloads(repoName string, length int, packages string) {
|
|||
}
|
||||
|
||||
// PrintInfo prints package info like pacman -Si.
|
||||
func PrintInfo(a *rpc.Pkg) {
|
||||
func PrintInfo(a *rpc.Pkg, extendedInfo bool) {
|
||||
text.PrintInfoValue(gotext.Get("Repository"), "aur")
|
||||
text.PrintInfoValue(gotext.Get("Name"), a.Name)
|
||||
text.PrintInfoValue(gotext.Get("Keywords"), strings.Join(a.Keywords, " "))
|
||||
|
|
@ -295,7 +295,7 @@ func PrintInfo(a *rpc.Pkg) {
|
|||
text.PrintInfoValue(gotext.Get("Out-of-date"), "No")
|
||||
}
|
||||
|
||||
if cmdArgs.ExistsDouble("i") {
|
||||
if extendedInfo {
|
||||
text.PrintInfoValue("ID", fmt.Sprintf("%d", a.ID))
|
||||
text.PrintInfoValue(gotext.Get("Package Base ID"), fmt.Sprintf("%d", a.PackageBaseID))
|
||||
text.PrintInfoValue(gotext.Get("Package Base"), a.PackageBase)
|
||||
|
|
@ -354,11 +354,11 @@ func localStatistics(alpmHandle *alpm.Handle) error {
|
|||
}
|
||||
|
||||
//TODO: Make it less hacky
|
||||
func printNumberOfUpdates(alpmHandle *alpm.Handle) error {
|
||||
func printNumberOfUpdates(alpmHandle *alpm.Handle, enableDowngrade bool) error {
|
||||
warnings := makeWarnings()
|
||||
old := os.Stdout // keep backup of the real stdout
|
||||
os.Stdout = nil
|
||||
aurUp, repoUp, err := upList(warnings, alpmHandle)
|
||||
aurUp, repoUp, err := upList(warnings, alpmHandle, enableDowngrade)
|
||||
os.Stdout = old // restoring the real stdout
|
||||
if err != nil {
|
||||
return err
|
||||
|
|
@ -369,8 +369,8 @@ func printNumberOfUpdates(alpmHandle *alpm.Handle) error {
|
|||
}
|
||||
|
||||
//TODO: Make it less hacky
|
||||
func printUpdateList(parser *settings.Arguments, alpmHandle *alpm.Handle) error {
|
||||
targets := stringset.FromSlice(parser.Targets)
|
||||
func printUpdateList(cmdArgs *settings.Arguments, alpmHandle *alpm.Handle, enableDowngrade bool) error {
|
||||
targets := stringset.FromSlice(cmdArgs.Targets)
|
||||
warnings := makeWarnings()
|
||||
old := os.Stdout // keep backup of the real stdout
|
||||
os.Stdout = nil
|
||||
|
|
@ -379,7 +379,7 @@ func printUpdateList(parser *settings.Arguments, alpmHandle *alpm.Handle) error
|
|||
return err
|
||||
}
|
||||
|
||||
aurUp, repoUp, err := upList(warnings, alpmHandle)
|
||||
aurUp, repoUp, err := upList(warnings, alpmHandle, enableDowngrade)
|
||||
os.Stdout = old // restoring the real stdout
|
||||
if err != nil {
|
||||
return err
|
||||
|
|
@ -387,10 +387,10 @@ func printUpdateList(parser *settings.Arguments, alpmHandle *alpm.Handle) error
|
|||
|
||||
noTargets := len(targets) == 0
|
||||
|
||||
if !parser.ExistsArg("m", "foreign") {
|
||||
if !cmdArgs.ExistsArg("m", "foreign") {
|
||||
for _, pkg := range repoUp {
|
||||
if noTargets || targets.Get(pkg.Name) {
|
||||
if parser.ExistsArg("q", "quiet") {
|
||||
if cmdArgs.ExistsArg("q", "quiet") {
|
||||
fmt.Printf("%s\n", pkg.Name)
|
||||
} else {
|
||||
fmt.Printf("%s %s -> %s\n", bold(pkg.Name), green(pkg.LocalVersion), green(pkg.RemoteVersion))
|
||||
|
|
@ -400,10 +400,10 @@ func printUpdateList(parser *settings.Arguments, alpmHandle *alpm.Handle) error
|
|||
}
|
||||
}
|
||||
|
||||
if !parser.ExistsArg("n", "native") {
|
||||
if !cmdArgs.ExistsArg("n", "native") {
|
||||
for _, pkg := range aurUp {
|
||||
if noTargets || targets.Get(pkg.Name) {
|
||||
if parser.ExistsArg("q", "quiet") {
|
||||
if cmdArgs.ExistsArg("q", "quiet") {
|
||||
fmt.Printf("%s\n", pkg.Name)
|
||||
} else {
|
||||
fmt.Printf("%s %s -> %s\n", bold(pkg.Name), green(pkg.LocalVersion), green(pkg.RemoteVersion))
|
||||
|
|
|
|||
4
query.go
4
query.go
|
|
@ -198,7 +198,7 @@ func syncSearch(pkgS []string, alpmHandle *alpm.Handle) (err error) {
|
|||
}
|
||||
|
||||
// SyncInfo serves as a pacman -Si for repo packages and AUR packages.
|
||||
func syncInfo(pkgS []string, alpmHandle *alpm.Handle) error {
|
||||
func syncInfo(pkgS []string, alpmHandle *alpm.Handle, cmdArgs *settings.Arguments) error {
|
||||
var info []*rpc.Pkg
|
||||
missing := false
|
||||
pkgS = removeInvalidTargets(pkgS)
|
||||
|
|
@ -240,7 +240,7 @@ func syncInfo(pkgS []string, alpmHandle *alpm.Handle) error {
|
|||
|
||||
if len(info) != 0 {
|
||||
for _, pkg := range info {
|
||||
PrintInfo(pkg)
|
||||
PrintInfo(pkg, cmdArgs.ExistsDouble("i"))
|
||||
}
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -118,7 +118,7 @@ func getVersionDiff(oldVersion, newVersion string) (left, right string) {
|
|||
}
|
||||
|
||||
// upList returns lists of packages to upgrade from each source.
|
||||
func upList(warnings *aurWarnings, alpmHandle *alpm.Handle) (aurUp, repoUp upSlice, err error) {
|
||||
func upList(warnings *aurWarnings, alpmHandle *alpm.Handle, enableDowngrade bool) (aurUp, repoUp upSlice, err error) {
|
||||
_, remote, _, remoteNames, err := query.FilterPackages(alpmHandle)
|
||||
if err != nil {
|
||||
return nil, nil, err
|
||||
|
|
@ -140,7 +140,7 @@ func upList(warnings *aurWarnings, alpmHandle *alpm.Handle) (aurUp, repoUp upSli
|
|||
text.OperationInfoln(gotext.Get("Searching databases for updates..."))
|
||||
wg.Add(1)
|
||||
go func() {
|
||||
repoUp, err = upRepo(alpmHandle)
|
||||
repoUp, err = upRepo(alpmHandle, enableDowngrade)
|
||||
errs.Add(err)
|
||||
wg.Done()
|
||||
}()
|
||||
|
|
@ -298,7 +298,7 @@ func printLocalNewerThanAUR(
|
|||
|
||||
// upRepo gathers local packages and checks if they have new versions.
|
||||
// Output: Upgrade type package list.
|
||||
func upRepo(alpmHandle *alpm.Handle) (upSlice, error) {
|
||||
func upRepo(alpmHandle *alpm.Handle, enableDowngrade bool) (upSlice, error) {
|
||||
slice := upSlice{}
|
||||
|
||||
localDB, err := alpmHandle.LocalDB()
|
||||
|
|
@ -315,7 +315,7 @@ func upRepo(alpmHandle *alpm.Handle) (upSlice, error) {
|
|||
err = alpmHandle.TransRelease()
|
||||
}()
|
||||
|
||||
err = alpmHandle.SyncSysupgrade(cmdArgs.ExistsDouble("u", "sysupgrade"))
|
||||
err = alpmHandle.SyncSysupgrade(enableDowngrade)
|
||||
if err != nil {
|
||||
return slice, err
|
||||
}
|
||||
|
|
|
|||
Loading…
Reference in a new issue