system/yay
system/yay
1
0
Fork 0
mirror of https://github.com/Jguer/yay synced 2024-10-01 13:53:32 +00:00
Code Issues Packages Projects Releases Wiki Activity

chore(yay): remove global cfg (#1946)

Browse source 
remove global cfg
This commit is contained in:
Jo 2023-03-05 21:58:18 +00:00 committed by GitHub
parent 8b8d6001a4
commit e6ed869df1
No known key found for this signature in database
GPG key ID: 4AEE18F83AFDEB23
10 changed files with 244 additions and 225 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

42
clean.go
View file

@ -18,17 +18,19 @@ import (
)
// CleanDependencies removes all dangling dependencies in system.
func cleanDependencies(ctx context.Context, cmdArgs *parser.Arguments, dbExecutor db.Executor, removeOptional bool) error {
func cleanDependencies(ctx context.Context, cfg *settings.Configuration,
cmdArgs *parser.Arguments, dbExecutor db.Executor, removeOptional bool,
) error {
hanging := hangingPackages(removeOptional, dbExecutor)
if len(hanging) != 0 {
return cleanRemove(ctx, cmdArgs, hanging)
return cleanRemove(ctx, cfg, cmdArgs, hanging)
}
return nil
}
// CleanRemove sends a full removal command to pacman with the pkgName slice.
func cleanRemove(ctx context.Context, cmdArgs *parser.Arguments, pkgNames []string) error {
func cleanRemove(ctx context.Context, config *settings.Configuration, cmdArgs *parser.Arguments, pkgNames []string) error {
if len(pkgNames) == 0 {
return nil
}
@ -42,13 +44,13 @@ func cleanRemove(ctx context.Context, cmdArgs *parser.Arguments, pkgNames []stri
arguments, config.Runtime.Mode, settings.NoConfirm))
}
func syncClean(ctx context.Context, cmdArgs *parser.Arguments, dbExecutor db.Executor) error {
func syncClean(ctx context.Context, cfg *settings.Configuration, cmdArgs *parser.Arguments, dbExecutor db.Executor) error {
keepInstalled := false
keepCurrent := false
_, removeAll, _ := cmdArgs.GetArg("c", "clean")
for _, v := range config.Runtime.PacmanConf.CleanMethod {
for _, v := range cfg.Runtime.PacmanConf.CleanMethod {
if v == "KeepInstalled" {
keepInstalled = true
} else if v == "KeepCurrent" {
@ -56,14 +58,14 @@ func syncClean(ctx context.Context, cmdArgs *parser.Arguments, dbExecutor db.Exe
}
}
if config.Runtime.Mode.AtLeastRepo() {
if err := config.Runtime.CmdBuilder.Show(config.Runtime.CmdBuilder.BuildPacmanCmd(ctx,
cmdArgs, config.Runtime.Mode, settings.NoConfirm)); err != nil {
if cfg.Runtime.Mode.AtLeastRepo() {
if err := cfg.Runtime.CmdBuilder.Show(cfg.Runtime.CmdBuilder.BuildPacmanCmd(ctx,
cmdArgs, cfg.Runtime.Mode, settings.NoConfirm)); err != nil {
return err
}
}
if !config.Runtime.Mode.AtLeastAUR() {
if !cfg.Runtime.Mode.AtLeastAUR() {
return nil
}
@ -74,10 +76,10 @@ func syncClean(ctx context.Context, cmdArgs *parser.Arguments, dbExecutor db.Exe
question = gotext.Get("Do you want to remove all other AUR packages from cache?")
}
fmt.Println(gotext.Get("\nBuild directory:"), config.BuildDir)
fmt.Println(gotext.Get("\nBuild directory:"), cfg.BuildDir)
if text.ContinueTask(os.Stdin, question, true, settings.NoConfirm) {
if err := cleanAUR(ctx, keepInstalled, keepCurrent, removeAll, dbExecutor); err != nil {
if err := cleanAUR(ctx, cfg, keepInstalled, keepCurrent, removeAll, dbExecutor); err != nil {
return err
}
}
@ -87,13 +89,15 @@ func syncClean(ctx context.Context, cmdArgs *parser.Arguments, dbExecutor db.Exe
}
if text.ContinueTask(os.Stdin, gotext.Get("Do you want to remove ALL untracked AUR files?"), true, settings.NoConfirm) {
return cleanUntracked(ctx)
return cleanUntracked(ctx, cfg)
}
return nil
}
func cleanAUR(ctx context.Context, keepInstalled, keepCurrent, removeAll bool, dbExecutor db.Executor) error {
func cleanAUR(ctx context.Context, config *settings.Configuration,
keepInstalled, keepCurrent, removeAll bool, dbExecutor db.Executor,
) error {
fmt.Println(gotext.Get("removing AUR packages from cache..."))
installedBases := make(stringset.StringSet)
@ -164,10 +168,10 @@ func cleanAUR(ctx context.Context, keepInstalled, keepCurrent, removeAll bool, d
return nil
}
func cleanUntracked(ctx context.Context) error {
func cleanUntracked(ctx context.Context, cfg *settings.Configuration) error {
fmt.Println(gotext.Get("removing untracked AUR files from cache..."))
files, err := os.ReadDir(config.BuildDir)
files, err := os.ReadDir(cfg.BuildDir)
if err != nil {
return err
}
@ -177,9 +181,9 @@ func cleanUntracked(ctx context.Context) error {
continue
}
dir := filepath.Join(config.BuildDir, file.Name())
dir := filepath.Join(cfg.BuildDir, file.Name())
if isGitRepository(dir) {
if err := config.Runtime.CmdBuilder.Show(config.Runtime.CmdBuilder.BuildGitCmd(ctx, dir, "clean", "-fx")); err != nil {
if err := cfg.Runtime.CmdBuilder.Show(cfg.Runtime.CmdBuilder.BuildGitCmd(ctx, dir, "clean", "-fx")); err != nil {
text.Warnln(gotext.Get("Unable to clean:"), dir)
return err
@ -195,7 +199,9 @@ func isGitRepository(dir string) bool {
return !os.IsNotExist(err)
}
func cleanAfter(ctx context.Context, cmdBuilder exe.ICmdBuilder, pkgbuildDirs map[string]string) {
func cleanAfter(ctx context.Context, config *settings.Configuration,
cmdBuilder exe.ICmdBuilder, pkgbuildDirs map[string]string,
) {
fmt.Println(gotext.Get("removing untracked AUR files from cache..."))
i := 0

115
cmd.go
View file

@ -151,7 +151,7 @@ getpkgbuild specific options:
func handleCmd(ctx context.Context, cfg *settings.Configuration, cmdArgs *parser.Arguments, dbExecutor db.Executor) error {
if cmdArgs.ExistsArg("h", "help") {
return handleHelp(ctx, cmdArgs)
return handleHelp(ctx, cfg, cmdArgs)
}
if cfg.SudoLoop && cmdArgs.NeedRoot(cfg.Runtime.Mode) {
@ -170,9 +170,9 @@ func handleCmd(ctx context.Context, cfg *settings.Configuration, cmdArgs *parser
return cfg.Runtime.CmdBuilder.Show(cfg.Runtime.CmdBuilder.BuildPacmanCmd(ctx,
cmdArgs, cfg.Runtime.Mode, settings.NoConfirm))
case "Q", "query":
return handleQuery(ctx, cmdArgs, dbExecutor)
return handleQuery(ctx, cfg, cmdArgs, dbExecutor)
case "R", "remove":
return handleRemove(ctx, cmdArgs, cfg.Runtime.VCSStore)
return handleRemove(ctx, cfg, cmdArgs, cfg.Runtime.VCSStore)
case "S", "sync":
return handleSync(ctx, cfg, cmdArgs, dbExecutor)
case "T", "deptest":
@ -183,13 +183,13 @@ func handleCmd(ctx context.Context, cfg *settings.Configuration, cmdArgs *parser
case "B", "build":
return handleBuild(ctx, cfg, dbExecutor, cmdArgs)
case "G", "getpkgbuild":
return handleGetpkgbuild(ctx, cmdArgs, dbExecutor)
return handleGetpkgbuild(ctx, cfg, cmdArgs, dbExecutor)
case "P", "show":
return handlePrint(ctx, cmdArgs, dbExecutor)
return handlePrint(ctx, cfg, cmdArgs, dbExecutor)
case "Y", "yay":
return handleYay(ctx, cmdArgs, dbExecutor, cfg.Runtime.QueryBuilder)
return handleYay(ctx, cfg, cmdArgs, dbExecutor, cfg.Runtime.QueryBuilder)
case "W", "web":
return handleWeb(ctx, cmdArgs)
return handleWeb(ctx, cfg, cmdArgs)
}
return errors.New(gotext.Get("unhandled operation"))
@ -219,18 +219,19 @@ func getFilter(cmdArgs *parser.Arguments) (upgrade.Filter, error) {
}, nil
}
func handleQuery(ctx context.Context, cmdArgs *parser.Arguments, dbExecutor db.Executor) error {
func handleQuery(ctx context.Context, cfg *settings.Configuration, cmdArgs *parser.Arguments, dbExecutor db.Executor) error {
if cmdArgs.ExistsArg("u", "upgrades") {
filter, err := getFilter(cmdArgs)
if err != nil {
return err
}
return printUpdateList(ctx, cmdArgs, dbExecutor, cmdArgs.ExistsDouble("u", "sysupgrade"), filter)
return printUpdateList(ctx, cfg, cmdArgs, dbExecutor,
cmdArgs.ExistsDouble("u", "sysupgrade"), filter)
}
if err := config.Runtime.CmdBuilder.Show(config.Runtime.CmdBuilder.BuildPacmanCmd(ctx,
cmdArgs, config.Runtime.Mode, settings.NoConfirm)); err != nil {
if err := cfg.Runtime.CmdBuilder.Show(cfg.Runtime.CmdBuilder.BuildPacmanCmd(ctx,
cmdArgs, cfg.Runtime.Mode, settings.NoConfirm)); err != nil {
if str := err.Error(); strings.Contains(str, "exit status") {
// yay -Qdt should not output anything in case of error
return fmt.Errorf("")
@ -242,22 +243,22 @@ func handleQuery(ctx context.Context, cmdArgs *parser.Arguments, dbExecutor db.E
return nil
}
func handleHelp(ctx context.Context, cmdArgs *parser.Arguments) error {
func handleHelp(ctx context.Context, cfg *settings.Configuration, cmdArgs *parser.Arguments) error {
switch cmdArgs.Op {
case "Y", "yay", "G", "getpkgbuild", "P", "show", "W", "web", "B", "build":
usage()
return nil
}
return config.Runtime.CmdBuilder.Show(config.Runtime.CmdBuilder.BuildPacmanCmd(ctx,
cmdArgs, config.Runtime.Mode, settings.NoConfirm))
return cfg.Runtime.CmdBuilder.Show(cfg.Runtime.CmdBuilder.BuildPacmanCmd(ctx,
cmdArgs, cfg.Runtime.Mode, settings.NoConfirm))
}
func handleVersion() {
fmt.Printf("yay v%s - libalpm v%s\n", yayVersion, alpm.Version())
}
func handlePrint(ctx context.Context, cmdArgs *parser.Arguments, dbExecutor db.Executor) error {
func handlePrint(ctx context.Context, cfg *settings.Configuration, cmdArgs *parser.Arguments, dbExecutor db.Executor) error {
switch {
case cmdArgs.ExistsArg("d", "defaultconfig"):
tmpConfig := settings.DefaultConfig(yayVersion)
@ -265,7 +266,7 @@ func handlePrint(ctx context.Context, cmdArgs *parser.Arguments, dbExecutor db.E
return nil
case cmdArgs.ExistsArg("g", "currentconfig"):
fmt.Printf("%v", config)
fmt.Printf("%v", cfg)
return nil
case cmdArgs.ExistsArg("n", "numberupgrades"):
@ -274,60 +275,62 @@ func handlePrint(ctx context.Context, cmdArgs *parser.Arguments, dbExecutor db.E
return err
}
return printNumberOfUpdates(ctx, dbExecutor, cmdArgs.ExistsDouble("u", "sysupgrade"), filter)
return printNumberOfUpdates(ctx, cfg, dbExecutor, cmdArgs.ExistsDouble("u", "sysupgrade"), filter)
case cmdArgs.ExistsArg("w", "news"):
double := cmdArgs.ExistsDouble("w", "news")
quiet := cmdArgs.ExistsArg("q", "quiet")
return news.PrintNewsFeed(ctx, config.Runtime.HTTPClient, dbExecutor.LastBuildTime(), config.BottomUp, double, quiet)
return news.PrintNewsFeed(ctx, cfg.Runtime.HTTPClient, dbExecutor.LastBuildTime(), cfg.BottomUp, double, quiet)
case cmdArgs.ExistsDouble("c", "complete"):
return completion.Show(ctx, config.Runtime.HTTPClient, dbExecutor,
config.AURURL, config.Runtime.CompletionPath, config.CompletionInterval, true)
return completion.Show(ctx, cfg.Runtime.HTTPClient, dbExecutor,
cfg.AURURL, cfg.Runtime.CompletionPath, cfg.CompletionInterval, true)
case cmdArgs.ExistsArg("c", "complete"):
return completion.Show(ctx, config.Runtime.HTTPClient, dbExecutor,
config.AURURL, config.Runtime.CompletionPath, config.CompletionInterval, false)
return completion.Show(ctx, cfg.Runtime.HTTPClient, dbExecutor,
cfg.AURURL, cfg.Runtime.CompletionPath, cfg.CompletionInterval, false)
case cmdArgs.ExistsArg("s", "stats"):
return localStatistics(ctx, dbExecutor)
return localStatistics(ctx, cfg, dbExecutor)
}
return nil
}
func handleYay(ctx context.Context, cmdArgs *parser.Arguments, dbExecutor db.Executor, queryBuilder query.Builder) error {
func handleYay(ctx context.Context, cfg *settings.Configuration,
cmdArgs *parser.Arguments, dbExecutor db.Executor, queryBuilder query.Builder,
) error {
switch {
case cmdArgs.ExistsArg("gendb"):
return createDevelDB(ctx, config, dbExecutor)
return createDevelDB(ctx, cfg, dbExecutor)
case cmdArgs.ExistsDouble("c"):
return cleanDependencies(ctx, cmdArgs, dbExecutor, true)
return cleanDependencies(ctx, cfg, cmdArgs, dbExecutor, true)
case cmdArgs.ExistsArg("c", "clean"):
return cleanDependencies(ctx, cmdArgs, dbExecutor, false)
return cleanDependencies(ctx, cfg, cmdArgs, dbExecutor, false)
case len(cmdArgs.Targets) > 0:
return displayNumberMenu(ctx, cmdArgs.Targets, dbExecutor, queryBuilder, cmdArgs)
return displayNumberMenu(ctx, cfg, cmdArgs.Targets, dbExecutor, queryBuilder, cmdArgs)
}
return nil
}
func handleWeb(ctx context.Context, cmdArgs *parser.Arguments) error {
func handleWeb(ctx context.Context, cfg *settings.Configuration, cmdArgs *parser.Arguments) error {
switch {
case cmdArgs.ExistsArg("v", "vote"):
return handlePackageVote(ctx, cmdArgs.Targets, config.Runtime.AURClient,
config.Runtime.VoteClient, config.RequestSplitN, true)
return handlePackageVote(ctx, cmdArgs.Targets, cfg.Runtime.AURClient,
cfg.Runtime.VoteClient, cfg.RequestSplitN, true)
case cmdArgs.ExistsArg("u", "unvote"):
return handlePackageVote(ctx, cmdArgs.Targets, config.Runtime.AURClient,
config.Runtime.VoteClient, config.RequestSplitN, false)
return handlePackageVote(ctx, cmdArgs.Targets, cfg.Runtime.AURClient,
cfg.Runtime.VoteClient, cfg.RequestSplitN, false)
}
return nil
}
func handleGetpkgbuild(ctx context.Context, cmdArgs *parser.Arguments, dbExecutor download.DBSearcher) error {
func handleGetpkgbuild(ctx context.Context, cfg *settings.Configuration, cmdArgs *parser.Arguments, dbExecutor download.DBSearcher) error {
if cmdArgs.ExistsArg("p", "print") {
return printPkgbuilds(dbExecutor, config.Runtime.AURCache,
config.Runtime.HTTPClient, cmdArgs.Targets, config.Runtime.Mode, config.AURURL)
return printPkgbuilds(dbExecutor, cfg.Runtime.AURCache,
cfg.Runtime.HTTPClient, cmdArgs.Targets, cfg.Runtime.Mode, cfg.AURURL)
}
return getPkgbuilds(ctx, dbExecutor, config.Runtime.AURCache, config,
return getPkgbuilds(ctx, dbExecutor, cfg.Runtime.AURCache, cfg,
cmdArgs.Targets, cmdArgs.ExistsArg("f", "force"))
}
@ -359,20 +362,20 @@ func handleSync(ctx context.Context, cfg *settings.Configuration, cmdArgs *parse
return cfg.Runtime.CmdBuilder.Show(cfg.Runtime.CmdBuilder.BuildPacmanCmd(ctx,
cmdArgs, cfg.Runtime.Mode, settings.NoConfirm))
case cmdArgs.ExistsArg("c", "clean"):
return syncClean(ctx, cmdArgs, dbExecutor)
return syncClean(ctx, cfg, cmdArgs, dbExecutor)
case cmdArgs.ExistsArg("l", "list"):
return syncList(ctx, cfg.Runtime.HTTPClient, cmdArgs, dbExecutor)
return syncList(ctx, cfg, cfg.Runtime.HTTPClient, cmdArgs, dbExecutor)
case cmdArgs.ExistsArg("g", "groups"):
return cfg.Runtime.CmdBuilder.Show(cfg.Runtime.CmdBuilder.BuildPacmanCmd(ctx,
cmdArgs, cfg.Runtime.Mode, settings.NoConfirm))
case cmdArgs.ExistsArg("i", "info"):
return syncInfo(ctx, cmdArgs, targets, dbExecutor)
return syncInfo(ctx, cfg, cmdArgs, targets, dbExecutor)
case cmdArgs.ExistsArg("u", "sysupgrade") || len(cmdArgs.Targets) > 0:
if cfg.NewInstallEngine {
return syncInstall(ctx, cfg, cmdArgs, dbExecutor)
}
return install(ctx, cmdArgs, dbExecutor, false)
return install(ctx, cfg, cmdArgs, dbExecutor, false)
case cmdArgs.ExistsArg("y", "refresh"):
return cfg.Runtime.CmdBuilder.Show(cfg.Runtime.CmdBuilder.BuildPacmanCmd(ctx,
cmdArgs, cfg.Runtime.Mode, settings.NoConfirm))
@ -381,9 +384,9 @@ func handleSync(ctx context.Context, cfg *settings.Configuration, cmdArgs *parse
return nil
}
func handleRemove(ctx context.Context, cmdArgs *parser.Arguments, localCache vcs.Store) error {
err := config.Runtime.CmdBuilder.Show(config.Runtime.CmdBuilder.BuildPacmanCmd(ctx,
cmdArgs, config.Runtime.Mode, settings.NoConfirm))
func handleRemove(ctx context.Context, cfg *settings.Configuration, cmdArgs *parser.Arguments, localCache vcs.Store) error {
err := cfg.Runtime.CmdBuilder.Show(cfg.Runtime.CmdBuilder.BuildPacmanCmd(ctx,
cmdArgs, cfg.Runtime.Mode, settings.NoConfirm))
if err == nil {
localCache.RemovePackages(cmdArgs.Targets)
}
@ -392,7 +395,7 @@ func handleRemove(ctx context.Context, cmdArgs *parser.Arguments, localCache vcs
}
// NumberMenu presents a CLI for selecting packages to install.
func displayNumberMenu(ctx context.Context, pkgS []string, dbExecutor db.Executor,
func displayNumberMenu(ctx context.Context, cfg *settings.Configuration, pkgS []string, dbExecutor db.Executor,
queryBuilder query.Builder, cmdArgs *parser.Arguments,
) error {
queryBuilder.Execute(ctx, dbExecutor, pkgS)
@ -429,25 +432,27 @@ func displayNumberMenu(ctx context.Context, pkgS []string, dbExecutor db.Executo
return nil
}
if config.NewInstallEngine {
return syncInstall(ctx, config, cmdArgs, dbExecutor)
if cfg.NewInstallEngine {
return syncInstall(ctx, cfg, cmdArgs, dbExecutor)
}
return install(ctx, cmdArgs, dbExecutor, true)
return install(ctx, cfg, cmdArgs, dbExecutor, true)
}
func syncList(ctx context.Context, httpClient *http.Client, cmdArgs *parser.Arguments, dbExecutor db.Executor) error {
func syncList(ctx context.Context, cfg *settings.Configuration,
httpClient *http.Client, cmdArgs *parser.Arguments, dbExecutor db.Executor,
) error {
aur := false
for i := len(cmdArgs.Targets) - 1; i >= 0; i-- {
if cmdArgs.Targets[i] == "aur" && config.Runtime.Mode.AtLeastAUR() {
if cmdArgs.Targets[i] == "aur" && cfg.Runtime.Mode.AtLeastAUR() {
cmdArgs.Targets = append(cmdArgs.Targets[:i], cmdArgs.Targets[i+1:]...)
aur = true
}
}
if config.Runtime.Mode.AtLeastAUR() && (len(cmdArgs.Targets) == 0 || aur) {
req, err := http.NewRequestWithContext(ctx, http.MethodGet, config.AURURL+"/packages.gz", http.NoBody)
if cfg.Runtime.Mode.AtLeastAUR() && (len(cmdArgs.Targets) == 0 || aur) {
req, err := http.NewRequestWithContext(ctx, http.MethodGet, cfg.AURURL+"/packages.gz", http.NoBody)
if err != nil {
return err
}
@ -478,9 +483,9 @@ func syncList(ctx context.Context, httpClient *http.Client, cmdArgs *parser.Argu
}
}
if config.Runtime.Mode.AtLeastRepo() && (len(cmdArgs.Targets) != 0 || !aur) {
return config.Runtime.CmdBuilder.Show(config.Runtime.CmdBuilder.BuildPacmanCmd(ctx,
cmdArgs, config.Runtime.Mode, settings.NoConfirm))
if cfg.Runtime.Mode.AtLeastRepo() && (len(cmdArgs.Targets) != 0 || !aur) {
return cfg.Runtime.CmdBuilder.Show(cfg.Runtime.CmdBuilder.BuildPacmanCmd(ctx,
cmdArgs, cfg.Runtime.Mode, settings.NoConfirm))
}
return nil

10
globals.go
View file

@ -1,10 +0,0 @@
package main
import "github.com/Jguer/yay/v11/pkg/settings"
var (
yayVersion = "11.3.0" // To be set by compiler.
localePath = "/usr/share/locale" // To be set by compiler.
)
var config *settings.Configuration // YayConf holds the current config values for yay.

162
install.go
View file

@ -85,12 +85,14 @@ func asexp(ctx context.Context,
}
// Install handles package installs.
func install(ctx context.Context, cmdArgs *parser.Arguments, dbExecutor db.Executor, ignoreProviders bool) error {
func install(ctx context.Context, cfg *settings.Configuration,
cmdArgs *parser.Arguments, dbExecutor db.Executor, ignoreProviders bool,
) error {
var (
do *dep.Order
srcinfos map[string]*gosrc.Srcinfo
noDeps = cmdArgs.ExistsDouble("d", "nodeps")
noCheck = strings.Contains(config.MFlags, "--nocheck")
noCheck = strings.Contains(cfg.MFlags, "--nocheck")
assumeInstalled = cmdArgs.GetArgs("assume-installed")
sysupgradeArg = cmdArgs.ExistsArg("u", "sysupgrade")
refreshArg = cmdArgs.ExistsArg("y", "refresh")
@ -98,19 +100,19 @@ func install(ctx context.Context, cmdArgs *parser.Arguments, dbExecutor db.Execu
)
if noDeps {
config.Runtime.CmdBuilder.AddMakepkgFlag("-d")
cfg.Runtime.CmdBuilder.AddMakepkgFlag("-d")
}
if config.Runtime.Mode.AtLeastRepo() {
if config.CombinedUpgrade {
if cfg.Runtime.Mode.AtLeastRepo() {
if cfg.CombinedUpgrade {
if refreshArg {
if errR := earlyRefresh(ctx, config, config.Runtime.CmdBuilder, cmdArgs); errR != nil {
if errR := earlyRefresh(ctx, cfg, cfg.Runtime.CmdBuilder, cmdArgs); errR != nil {
return fmt.Errorf("%s - %w", gotext.Get("error refreshing databases"), errR)
}
cmdArgs.DelArg("y", "refresh")
}
} else if refreshArg || sysupgradeArg || len(cmdArgs.Targets) > 0 {
if errP := earlyPacmanCall(ctx, cmdArgs, dbExecutor); errP != nil {
if errP := earlyPacmanCall(ctx, cfg, cmdArgs, dbExecutor); errP != nil {
return errP
}
}
@ -137,7 +139,7 @@ func install(ctx context.Context, cmdArgs *parser.Arguments, dbExecutor db.Execu
arguments.Op = "S"
arguments.ClearTargets()
if config.Runtime.Mode == parser.ModeAUR {
if cfg.Runtime.Mode == parser.ModeAUR {
arguments.DelArg("u", "sysupgrade")
}
@ -145,7 +147,7 @@ func install(ctx context.Context, cmdArgs *parser.Arguments, dbExecutor db.Execu
if sysupgradeArg {
var errSysUp error
requestTargets, errSysUp = addUpgradeTargetsToArgs(ctx, dbExecutor, cmdArgs, requestTargets, arguments)
requestTargets, errSysUp = addUpgradeTargetsToArgs(ctx, cfg, dbExecutor, cmdArgs, requestTargets, arguments)
if errSysUp != nil {
return errSysUp
}
@ -154,8 +156,8 @@ func install(ctx context.Context, cmdArgs *parser.Arguments, dbExecutor db.Execu
targets := stringset.FromSlice(cmdArgs.Targets)
dp, err := dep.GetPool(ctx, requestTargets,
warnings, dbExecutor, config.Runtime.AURClient, config.Runtime.Mode,
ignoreProviders, settings.NoConfirm, config.Provides, config.ReBuild, config.RequestSplitN, noDeps, noCheck, assumeInstalled)
warnings, dbExecutor, cfg.Runtime.AURClient, cfg.Runtime.Mode,
ignoreProviders, settings.NoConfirm, cfg.Provides, cfg.ReBuild, cfg.RequestSplitN, noDeps, noCheck, assumeInstalled)
if err != nil {
return err
}
@ -165,7 +167,7 @@ func install(ctx context.Context, cmdArgs *parser.Arguments, dbExecutor db.Execu
}
if len(dp.Aur) == 0 {
if !config.CombinedUpgrade {
if !cfg.CombinedUpgrade {
if sysupgradeArg {
fmt.Println(gotext.Get(" there is nothing to do"))
}
@ -180,11 +182,11 @@ func install(ctx context.Context, cmdArgs *parser.Arguments, dbExecutor db.Execu
cmdArgs.CreateOrAppendOption("ignore", arguments.GetArgs("ignore")...)
}
return config.Runtime.CmdBuilder.Show(config.Runtime.CmdBuilder.BuildPacmanCmd(ctx,
cmdArgs, config.Runtime.Mode, settings.NoConfirm))
return cfg.Runtime.CmdBuilder.Show(cfg.Runtime.CmdBuilder.BuildPacmanCmd(ctx,
cmdArgs, cfg.Runtime.Mode, settings.NoConfirm))
}
conflicts, errCC := dp.CheckConflicts(config.UseAsk, settings.NoConfirm, noDeps)
conflicts, errCC := dp.CheckConflicts(cfg.UseAsk, settings.NoConfirm, noDeps)
if errCC != nil {
return errCC
}
@ -200,7 +202,7 @@ func install(ctx context.Context, cmdArgs *parser.Arguments, dbExecutor db.Execu
}
if len(do.Aur) == 0 && len(arguments.Targets) == 0 &&
(!cmdArgs.ExistsArg("u", "sysupgrade") || config.Runtime.Mode == parser.ModeAUR) {
(!cmdArgs.ExistsArg("u", "sysupgrade") || cfg.Runtime.Mode == parser.ModeAUR) {
fmt.Println(gotext.Get(" there is nothing to do"))
return nil
}
@ -211,21 +213,21 @@ func install(ctx context.Context, cmdArgs *parser.Arguments, dbExecutor db.Execu
pkgbuildDirs := make(map[string]string, len(do.Aur))
for _, base := range do.Aur {
dir := filepath.Join(config.BuildDir, base.Pkgbase())
dir := filepath.Join(cfg.BuildDir, base.Pkgbase())
pkgbuildDirs[base.Pkgbase()] = dir
}
if config.CleanAfter {
if cfg.CleanAfter {
defer func() {
cleanAfter(ctx, config.Runtime.CmdBuilder, pkgbuildDirs)
cleanAfter(ctx, cfg, cfg.Runtime.CmdBuilder, pkgbuildDirs)
}()
}
if do.HasMake() {
switch config.RemoveMake {
switch cfg.RemoveMake {
case "yes":
defer func() {
err = removeMake(ctx, config.Runtime.CmdBuilder, do.GetMake(), cmdArgs)
err = removeMake(ctx, cfg, cfg.Runtime.CmdBuilder, do.GetMake(), cmdArgs)
}()
case "no":
@ -233,15 +235,15 @@ func install(ctx context.Context, cmdArgs *parser.Arguments, dbExecutor db.Execu
default:
if text.ContinueTask(os.Stdin, gotext.Get("Remove make dependencies after install?"), false, settings.NoConfirm) {
defer func() {
err = removeMake(ctx, config.Runtime.CmdBuilder, do.GetMake(), cmdArgs)
err = removeMake(ctx, cfg, cfg.Runtime.CmdBuilder, do.GetMake(), cmdArgs)
}()
}
}
}
if errCleanMenu := menus.Clean(os.Stdout, config.CleanMenu,
if errCleanMenu := menus.Clean(os.Stdout, cfg.CleanMenu,
pkgbuildDirs,
remoteNamesCache, settings.NoConfirm, config.AnswerClean); errCleanMenu != nil {
remoteNamesCache, settings.NoConfirm, cfg.AnswerClean); errCleanMenu != nil {
if errors.As(errCleanMenu, &settings.ErrUserAbort{}) {
return errCleanMenu
}
@ -249,7 +251,7 @@ func install(ctx context.Context, cmdArgs *parser.Arguments, dbExecutor db.Execu
text.Errorln(errCleanMenu)
}
toSkip := pkgbuildsToSkip(do.Aur, targets)
toSkip := pkgbuildsToSkip(cfg, do.Aur, targets)
toClone := make([]string, 0, len(do.Aur))
for _, base := range do.Aur {
@ -265,14 +267,14 @@ func install(ctx context.Context, cmdArgs *parser.Arguments, dbExecutor db.Execu
}
cloned, errA := download.AURPKGBUILDRepos(ctx,
config.Runtime.CmdBuilder, toClone, config.AURURL, config.BuildDir, false)
cfg.Runtime.CmdBuilder, toClone, cfg.AURURL, cfg.BuildDir, false)
if errA != nil {
return errA
}
if errDiffMenu := menus.Diff(ctx, config.Runtime.CmdBuilder, os.Stdout, pkgbuildDirs,
config.DiffMenu, remoteNamesCache,
cloned, settings.NoConfirm, config.AnswerDiff); errDiffMenu != nil {
if errDiffMenu := menus.Diff(ctx, cfg.Runtime.CmdBuilder, os.Stdout, pkgbuildDirs,
cfg.DiffMenu, remoteNamesCache,
cloned, settings.NoConfirm, cfg.AnswerDiff); errDiffMenu != nil {
if errors.As(errDiffMenu, &settings.ErrUserAbort{}) {
return errDiffMenu
}
@ -280,7 +282,7 @@ func install(ctx context.Context, cmdArgs *parser.Arguments, dbExecutor db.Execu
text.Errorln(errDiffMenu)
}
if errM := mergePkgbuilds(ctx, config.Runtime.CmdBuilder, pkgbuildDirs); errM != nil {
if errM := mergePkgbuilds(ctx, cfg.Runtime.CmdBuilder, pkgbuildDirs); errM != nil {
return errM
}
@ -289,9 +291,9 @@ func install(ctx context.Context, cmdArgs *parser.Arguments, dbExecutor db.Execu
return err
}
if errEditMenu := menus.Edit(os.Stdout, config.EditMenu, pkgbuildDirs,
config.Editor, config.EditorFlags, remoteNamesCache, srcinfos,
settings.NoConfirm, config.AnswerEdit); errEditMenu != nil {
if errEditMenu := menus.Edit(os.Stdout, cfg.EditMenu, pkgbuildDirs,
cfg.Editor, cfg.EditorFlags, remoteNamesCache, srcinfos,
settings.NoConfirm, cfg.AnswerEdit); errEditMenu != nil {
if errors.As(errEditMenu, &settings.ErrUserAbort{}) {
return errEditMenu
}
@ -303,19 +305,19 @@ func install(ctx context.Context, cmdArgs *parser.Arguments, dbExecutor db.Execu
return errI
}
if config.PGPFetch {
if _, errCPK := pgp.CheckPgpKeys(ctx, pkgbuildDirs, srcinfos, config.Runtime.CmdBuilder, settings.NoConfirm); errCPK != nil {
if cfg.PGPFetch {
if _, errCPK := pgp.CheckPgpKeys(ctx, pkgbuildDirs, srcinfos, cfg.Runtime.CmdBuilder, settings.NoConfirm); errCPK != nil {
return errCPK
}
}
if !config.CombinedUpgrade {
if !cfg.CombinedUpgrade {
arguments.DelArg("u", "sysupgrade")
}
if len(arguments.Targets) > 0 || arguments.ExistsArg("u") {
if errShow := config.Runtime.CmdBuilder.Show(config.Runtime.CmdBuilder.BuildPacmanCmd(ctx,
arguments, config.Runtime.Mode, settings.NoConfirm)); errShow != nil {
if errShow := cfg.Runtime.CmdBuilder.Show(cfg.Runtime.CmdBuilder.BuildPacmanCmd(ctx,
arguments, cfg.Runtime.Mode, settings.NoConfirm)); errShow != nil {
return errors.New(gotext.Get("error installing repo packages"))
}
@ -336,38 +338,39 @@ func install(ctx context.Context, cmdArgs *parser.Arguments, dbExecutor db.Execu
}
}
if errDeps := asdeps(ctx, config.Runtime.CmdBuilder, config.Runtime.Mode, cmdArgs, deps); errDeps != nil {
if errDeps := asdeps(ctx, cfg.Runtime.CmdBuilder, cfg.Runtime.Mode, cmdArgs, deps); errDeps != nil {
return errDeps
}
if errExp := asexp(ctx, config.Runtime.CmdBuilder, config.Runtime.Mode, cmdArgs, exp); errExp != nil {
if errExp := asexp(ctx, cfg.Runtime.CmdBuilder, cfg.Runtime.Mode, cmdArgs, exp); errExp != nil {
return errExp
}
}
go func() {
_ = completion.Update(ctx, config.Runtime.HTTPClient, dbExecutor,
config.AURURL, config.Runtime.CompletionPath, config.CompletionInterval, false)
_ = completion.Update(ctx, cfg.Runtime.HTTPClient, dbExecutor,
cfg.AURURL, cfg.Runtime.CompletionPath, cfg.CompletionInterval, false)
}()
if errP := downloadPKGBUILDSourceFanout(ctx,
config.Runtime.CmdBuilder,
cfg.Runtime.CmdBuilder,
pkgbuildDirs,
true, config.MaxConcurrentDownloads); errP != nil {
true, cfg.MaxConcurrentDownloads); errP != nil {
text.Errorln(errP)
}
if errB := buildInstallPkgbuilds(ctx, cmdArgs, dbExecutor, dp, do, srcinfos, true, conflicts, noDeps, noCheck); errB != nil {
if errB := buildInstallPkgbuilds(ctx, cfg, cmdArgs, dbExecutor, dp, do,
srcinfos, true, conflicts, noDeps, noCheck); errB != nil {
return errB
}
return nil
}
func addUpgradeTargetsToArgs(ctx context.Context, dbExecutor db.Executor,
func addUpgradeTargetsToArgs(ctx context.Context, cfg *settings.Configuration, dbExecutor db.Executor,
cmdArgs *parser.Arguments, requestTargets []string, arguments *parser.Arguments,
) ([]string, error) {
ignore, targets, errUp := sysupgradeTargets(ctx, dbExecutor, cmdArgs.ExistsDouble("u", "sysupgrade"))
ignore, targets, errUp := sysupgradeTargets(ctx, cfg, dbExecutor, cmdArgs.ExistsDouble("u", "sysupgrade"))
if errUp != nil {
return nil, errUp
}
@ -384,7 +387,9 @@ func addUpgradeTargetsToArgs(ctx context.Context, dbExecutor db.Executor,
return requestTargets, nil
}
func removeMake(ctx context.Context, cmdBuilder exe.ICmdBuilder, makeDeps []string, cmdArgs *parser.Arguments) error {
func removeMake(ctx context.Context, config *settings.Configuration,
cmdBuilder exe.ICmdBuilder, makeDeps []string, cmdArgs *parser.Arguments,
) error {
removeArguments := cmdArgs.CopyGlobal()
err := removeArguments.AddArg("R", "u")
@ -422,14 +427,16 @@ func inRepos(dbExecutor db.Executor, pkg string) bool {
return exists || len(dbExecutor.PackagesFromGroup(target.Name)) > 0
}
func earlyPacmanCall(ctx context.Context, cmdArgs *parser.Arguments, dbExecutor db.Executor) error {
func earlyPacmanCall(ctx context.Context, cfg *settings.Configuration,
cmdArgs *parser.Arguments, dbExecutor db.Executor,
) error {
arguments := cmdArgs.Copy()
arguments.Op = "S"
targets := cmdArgs.Targets
cmdArgs.ClearTargets()
arguments.ClearTargets()
if config.Runtime.Mode == parser.ModeRepo {
if cfg.Runtime.Mode == parser.ModeRepo {
arguments.Targets = targets
} else {
// separate aur and repo targets
@ -443,8 +450,8 @@ func earlyPacmanCall(ctx context.Context, cmdArgs *parser.Arguments, dbExecutor
}
if cmdArgs.ExistsArg("y", "refresh") || cmdArgs.ExistsArg("u", "sysupgrade") || len(arguments.Targets) > 0 {
if err := config.Runtime.CmdBuilder.Show(config.Runtime.CmdBuilder.BuildPacmanCmd(ctx,
arguments, config.Runtime.Mode, settings.NoConfirm)); err != nil {
if err := cfg.Runtime.CmdBuilder.Show(cfg.Runtime.CmdBuilder.BuildPacmanCmd(ctx,
arguments, cfg.Runtime.Mode, settings.NoConfirm)); err != nil {
return errors.New(gotext.Get("error installing repo packages"))
}
}
@ -538,7 +545,7 @@ func parsePackageList(ctx context.Context, cmdBuilder exe.ICmdBuilder,
return pkgdests, pkgVersion, nil
}
func pkgbuildsToSkip(bases []dep.Base, targets stringset.StringSet) stringset.StringSet {
func pkgbuildsToSkip(cfg *settings.Configuration, bases []dep.Base, targets stringset.StringSet) stringset.StringSet {
toSkip := make(stringset.StringSet)
for _, base := range bases {
@ -547,11 +554,11 @@ func pkgbuildsToSkip(bases []dep.Base, targets stringset.StringSet) stringset.St
isTarget = isTarget || targets.Get(pkg.Name)
}
if (config.ReDownload == "yes" && isTarget) || config.ReDownload == "all" {
if (cfg.ReDownload == "yes" && isTarget) || cfg.ReDownload == "all" {
continue
}
dir := filepath.Join(config.BuildDir, base.Pkgbase(), ".SRCINFO")
dir := filepath.Join(cfg.BuildDir, base.Pkgbase(), ".SRCINFO")
pkgbuild, err := gosrc.ParseFile(dir)
if err == nil {
@ -595,6 +602,7 @@ func mergePkgbuilds(ctx context.Context, cmdBuilder exe.ICmdBuilder, pkgbuildDir
func buildInstallPkgbuilds(
ctx context.Context,
cfg *settings.Configuration,
cmdArgs *parser.Arguments,
dbExecutor db.Executor,
dp *dep.Pool,
@ -620,7 +628,7 @@ func buildInstallPkgbuilds(
for i, base := range do.Aur {
pkg := base.Pkgbase()
dir := filepath.Join(config.BuildDir, pkg)
dir := filepath.Join(cfg.BuildDir, pkg)
built := true
satisfied := true
@ -636,11 +644,11 @@ func buildInstallPkgbuilds(
}
}
if !satisfied || !config.BatchInstall {
if !satisfied || !cfg.BatchInstall {
text.Debugln("non batch installing archives:", pkgArchives)
errArchive := installPkgArchive(ctx, config.Runtime.CmdBuilder,
config.Runtime.Mode, config.Runtime.VCSStore, cmdArgs, pkgArchives)
errReason := setInstallReason(ctx, config.Runtime.CmdBuilder, config.Runtime.Mode, cmdArgs, deps, exp)
errArchive := installPkgArchive(ctx, cfg.Runtime.CmdBuilder,
cfg.Runtime.Mode, cfg.Runtime.VCSStore, cmdArgs, pkgArchives)
errReason := setInstallReason(ctx, cfg.Runtime.CmdBuilder, cfg.Runtime.Mode, cmdArgs, deps, exp)
deps = make([]string, 0)
exp = make([]string, 0)
@ -648,7 +656,7 @@ func buildInstallPkgbuilds(
if errArchive != nil || errReason != nil {
if i != 0 {
go config.Runtime.VCSStore.RemovePackages([]string{do.Aur[i-1].String()})
go cfg.Runtime.VCSStore.RemovePackages([]string{do.Aur[i-1].String()})
}
if errArchive != nil {
@ -668,12 +676,12 @@ func buildInstallPkgbuilds(
}
// pkgver bump
if err := config.Runtime.CmdBuilder.Show(
config.Runtime.CmdBuilder.BuildMakepkgCmd(ctx, dir, args...)); err != nil {
if err := cfg.Runtime.CmdBuilder.Show(
cfg.Runtime.CmdBuilder.BuildMakepkgCmd(ctx, dir, args...)); err != nil {
return errors.New(gotext.Get("error making: %s", base.String()))
}
pkgdests, pkgVersion, errList := parsePackageList(ctx, config.Runtime.CmdBuilder, dir)
pkgdests, pkgVersion, errList := parsePackageList(ctx, cfg.Runtime.CmdBuilder, dir)
if errList != nil {
return errList
}
@ -683,7 +691,7 @@ func buildInstallPkgbuilds(
isExplicit = isExplicit || dp.Explicit.Get(b.Name)
}
if config.ReBuild == "no" || (config.ReBuild == "yes" && !isExplicit) {
if cfg.ReBuild == "no" || (cfg.ReBuild == "yes" && !isExplicit) {
for _, split := range base {
pkgdest, ok := pkgdests[split.Name]
if !ok {
@ -707,8 +715,8 @@ func buildInstallPkgbuilds(
}
if installed {
err := config.Runtime.CmdBuilder.Show(
config.Runtime.CmdBuilder.BuildMakepkgCmd(ctx,
err := cfg.Runtime.CmdBuilder.Show(
cfg.Runtime.CmdBuilder.BuildMakepkgCmd(ctx,
dir, "-c", "--nobuild", "--noextract", "--ignorearch"))
if err != nil {
return errors.New(gotext.Get("error making: %s", err))
@ -721,8 +729,8 @@ func buildInstallPkgbuilds(
}
if built {
err := config.Runtime.CmdBuilder.Show(
config.Runtime.CmdBuilder.BuildMakepkgCmd(ctx,
err := cfg.Runtime.CmdBuilder.Show(
cfg.Runtime.CmdBuilder.BuildMakepkgCmd(ctx,
dir, "-c", "--nobuild", "--noextract", "--ignorearch"))
if err != nil {
return errors.New(gotext.Get("error making: %s", err))
@ -736,15 +744,15 @@ func buildInstallPkgbuilds(
args = append(args, "--ignorearch")
}
if errMake := config.Runtime.CmdBuilder.Show(
config.Runtime.CmdBuilder.BuildMakepkgCmd(ctx,
if errMake := cfg.Runtime.CmdBuilder.Show(
cfg.Runtime.CmdBuilder.BuildMakepkgCmd(ctx,
dir, args...)); errMake != nil {
return errors.New(gotext.Get("error making: %s", base.String()))
}
}
// conflicts have been checked so answer y for them
if config.UseAsk && cmdArgs.ExistsArg("ask") {
if cfg.UseAsk && cmdArgs.ExistsArg("ask") {
ask, _ := strconv.Atoi(cmdArgs.Options["ask"].First())
uask := alpm.QuestionType(ask) | alpm.QuestionTypeConflictPkg
cmdArgs.Options["ask"].Set(fmt.Sprint(uask))
@ -783,7 +791,7 @@ func buildInstallPkgbuilds(
text.Debugln("checking vcs store for:", pkg.Name)
go func(name string) {
config.Runtime.VCSStore.Update(ctx, name, srcInfo.Source)
cfg.Runtime.VCSStore.Update(ctx, name, srcInfo.Source)
wg.Done()
}(pkg.Name)
}
@ -792,14 +800,14 @@ func buildInstallPkgbuilds(
}
text.Debugln("installing archives:", pkgArchives)
errArchive := installPkgArchive(ctx, config.Runtime.CmdBuilder, config.Runtime.Mode, config.Runtime.VCSStore, cmdArgs, pkgArchives)
errArchive := installPkgArchive(ctx, cfg.Runtime.CmdBuilder, cfg.Runtime.Mode, cfg.Runtime.VCSStore, cmdArgs, pkgArchives)
if errArchive != nil {
go config.Runtime.VCSStore.RemovePackages([]string{do.Aur[len(do.Aur)-1].String()})
go cfg.Runtime.VCSStore.RemovePackages([]string{do.Aur[len(do.Aur)-1].String()})
}
errReason := setInstallReason(ctx, config.Runtime.CmdBuilder, config.Runtime.Mode, cmdArgs, deps, exp)
errReason := setInstallReason(ctx, cfg.Runtime.CmdBuilder, cfg.Runtime.Mode, cmdArgs, deps, exp)
if errReason != nil {
go config.Runtime.VCSStore.RemovePackages([]string{do.Aur[len(do.Aur)-1].String()})
go cfg.Runtime.VCSStore.RemovePackages([]string{do.Aur[len(do.Aur)-1].String()})
}
settings.NoConfirm = oldConfirm

49
main.go
View file

@ -17,6 +17,11 @@ import (
"github.com/Jguer/yay/v11/pkg/text"
)
var (
yayVersion = "11.3.0" // To be set by compiler.
localePath = "/usr/share/locale" // To be set by compiler.
)
func initGotext() {
if envLocalePath := os.Getenv("LOCALE_PATH"); envLocalePath != "" {
localePath = envLocalePath
@ -55,7 +60,7 @@ func main() {
text.Warnln(gotext.Get("Avoid running yay as root/sudo."))
}
config, err = settings.NewConfig(yayVersion)
cfg, err := settings.NewConfig(yayVersion)
if err != nil {
if str := err.Error(); str != "" {
text.Errorln(str)
@ -66,18 +71,18 @@ func main() {
return
}
if config.Debug {
if cfg.Debug {
text.GlobalLogger.Debug = true
}
if errS := config.RunMigrations(
settings.DefaultMigrations(), config.Runtime.ConfigPath); errS != nil {
if errS := cfg.RunMigrations(
settings.DefaultMigrations(), cfg.Runtime.ConfigPath); errS != nil {
text.Errorln(errS)
}
cmdArgs := parser.MakeArguments()
if err = config.ParseCommandLine(cmdArgs); err != nil {
if err = cfg.ParseCommandLine(cmdArgs); err != nil {
if str := err.Error(); str != "" {
text.Errorln(str)
}
@ -87,29 +92,29 @@ func main() {
return
}
if config.Runtime.SaveConfig {
if errS := config.Save(config.Runtime.ConfigPath); errS != nil {
if cfg.Runtime.SaveConfig {
if errS := cfg.Save(cfg.Runtime.ConfigPath); errS != nil {
text.Errorln(errS)
}
}
if config.SeparateSources {
config.Runtime.QueryBuilder = query.NewSourceQueryBuilder(
config.Runtime.AURClient, config.Runtime.AURCache,
config.Runtime.Logger.Child("querybuilder"), config.SortBy,
config.Runtime.Mode, config.SearchBy, config.BottomUp,
config.SingleLineResults, config.NewInstallEngine)
if cfg.SeparateSources {
cfg.Runtime.QueryBuilder = query.NewSourceQueryBuilder(
cfg.Runtime.AURClient, cfg.Runtime.AURCache,
cfg.Runtime.Logger.Child("querybuilder"), cfg.SortBy,
cfg.Runtime.Mode, cfg.SearchBy, cfg.BottomUp,
cfg.SingleLineResults, cfg.NewInstallEngine)
} else {
config.Runtime.QueryBuilder = query.NewMixedSourceQueryBuilder(
config.Runtime.AURClient, config.Runtime.AURCache,
config.Runtime.Logger.Child("mixed.querybuilder"), config.SortBy,
config.Runtime.Mode, config.SearchBy,
config.BottomUp, config.SingleLineResults, config.NewInstallEngine)
cfg.Runtime.QueryBuilder = query.NewMixedSourceQueryBuilder(
cfg.Runtime.AURClient, cfg.Runtime.AURCache,
cfg.Runtime.Logger.Child("mixed.querybuilder"), cfg.SortBy,
cfg.Runtime.Mode, cfg.SearchBy,
cfg.BottomUp, cfg.SingleLineResults, cfg.NewInstallEngine)
}
var useColor bool
config.Runtime.PacmanConf, useColor, err = settings.RetrievePacmanConfig(cmdArgs, config.PacmanConf)
cfg.Runtime.PacmanConf, useColor, err = settings.RetrievePacmanConfig(cmdArgs, cfg.PacmanConf)
if err != nil {
if str := err.Error(); str != "" {
text.Errorln(str)
@ -120,11 +125,11 @@ func main() {
return
}
config.Runtime.CmdBuilder.SetPacmanDBPath(config.Runtime.PacmanConf.DBPath)
cfg.Runtime.CmdBuilder.SetPacmanDBPath(cfg.Runtime.PacmanConf.DBPath)
text.UseColor = useColor
dbExecutor, err := ialpm.NewExecutor(config.Runtime.PacmanConf)
dbExecutor, err := ialpm.NewExecutor(cfg.Runtime.PacmanConf)
if err != nil {
if str := err.Error(); str != "" {
text.Errorln(str)
@ -144,7 +149,7 @@ func main() {
dbExecutor.Cleanup()
}()
if err = handleCmd(ctx, config, cmdArgs, db.Executor(dbExecutor)); err != nil {
if err = handleCmd(ctx, cfg, cmdArgs, db.Executor(dbExecutor)); err != nil {
if str := err.Error(); str != "" {
text.Errorln(str)
}

4
preparer.go
View file

@ -66,7 +66,7 @@ func (preper *Preparer) ShouldCleanAURDirs(pkgBuildDirs map[string]string) PostI
text.Debugln("added post install hook to clean up AUR dirs", pkgBuildDirs)
return func(ctx context.Context) error {
cleanAfter(ctx, preper.cfg.Runtime.CmdBuilder, pkgBuildDirs)
cleanAfter(ctx, preper.cfg, preper.cfg.Runtime.CmdBuilder, pkgBuildDirs)
return nil
}
}
@ -90,7 +90,7 @@ func (preper *Preparer) ShouldCleanMakeDeps(cmdArgs *parser.Arguments) PostInsta
text.Debugln("added post install hook to clean up AUR makedeps", preper.makeDeps)
return func(ctx context.Context) error {
return removeMake(ctx, preper.cfg.Runtime.CmdBuilder, preper.makeDeps, cmdArgs)
return removeMake(ctx, preper.cfg, preper.cfg.Runtime.CmdBuilder, preper.makeDeps, cmdArgs)
}
}

21
print.go
View file

@ -11,6 +11,7 @@ import (
"github.com/Jguer/yay/v11/pkg/db"
"github.com/Jguer/yay/v11/pkg/query"
"github.com/Jguer/yay/v11/pkg/settings"
"github.com/Jguer/yay/v11/pkg/settings/parser"
"github.com/Jguer/yay/v11/pkg/stringset"
"github.com/Jguer/yay/v11/pkg/text"
@ -18,7 +19,7 @@ import (
)
// PrintInfo prints package info like pacman -Si.
func PrintInfo(a *aur.Pkg, extendedInfo bool) {
func PrintInfo(config *settings.Configuration, a *aur.Pkg, extendedInfo bool) {
text.PrintInfoValue(gotext.Get("Repository"), "aur")
text.PrintInfoValue(gotext.Get("Name"), a.Name)
text.PrintInfoValue(gotext.Get("Keywords"), a.Keywords...)
@ -70,8 +71,8 @@ func biggestPackages(dbExecutor db.Executor) {
}
// localStatistics prints installed packages statistics.
func localStatistics(ctx context.Context, dbExecutor db.Executor) error {
info := statistics(dbExecutor)
func localStatistics(ctx context.Context, cfg *settings.Configuration, dbExecutor db.Executor) error {
info := statistics(cfg, dbExecutor)
remoteNames := dbExecutor.InstalledRemotePackageNames()
text.Infoln(gotext.Get("Yay version v%s", yayVersion))
@ -85,22 +86,24 @@ func localStatistics(ctx context.Context, dbExecutor db.Executor) error {
text.Infoln(gotext.Get("Size of pacman cache %s: %s", path, text.Cyan(text.Human(size))))
}
text.Infoln(gotext.Get("Size of yay cache %s: %s", config.BuildDir, text.Cyan(text.Human(info.yayCache))))
text.Infoln(gotext.Get("Size of yay cache %s: %s", cfg.BuildDir, text.Cyan(text.Human(info.yayCache))))
fmt.Println(text.Bold(text.Cyan("===========================================")))
text.Infoln(gotext.Get("Ten biggest packages:"))
biggestPackages(dbExecutor)
fmt.Println(text.Bold(text.Cyan("===========================================")))
query.AURInfoPrint(ctx, config.Runtime.AURClient, remoteNames, config.RequestSplitN)
query.AURInfoPrint(ctx, cfg.Runtime.AURClient, remoteNames, cfg.RequestSplitN)
return nil
}
func printNumberOfUpdates(ctx context.Context, dbExecutor db.Executor, enableDowngrade bool, filter upgrade.Filter) error {
func printNumberOfUpdates(ctx context.Context, cfg *settings.Configuration,
dbExecutor db.Executor, enableDowngrade bool, filter upgrade.Filter,
) error {
warnings := query.NewWarnings()
old := os.Stdout // keep backup of the real stdout
os.Stdout = nil
aurUp, repoUp, err := upList(ctx, warnings, dbExecutor, enableDowngrade, filter)
aurUp, repoUp, err := upList(ctx, cfg, warnings, dbExecutor, enableDowngrade, filter)
os.Stdout = old // restoring the real stdout
if err != nil {
@ -112,7 +115,7 @@ func printNumberOfUpdates(ctx context.Context, dbExecutor db.Executor, enableDow
return nil
}
func printUpdateList(ctx context.Context, cmdArgs *parser.Arguments,
func printUpdateList(ctx context.Context, cfg *settings.Configuration, cmdArgs *parser.Arguments,
dbExecutor db.Executor, enableDowngrade bool, filter upgrade.Filter,
) error {
targets := stringset.FromSlice(cmdArgs.Targets)
@ -123,7 +126,7 @@ func printUpdateList(ctx context.Context, cmdArgs *parser.Arguments,
remoteNames := dbExecutor.InstalledRemotePackageNames()
localNames := dbExecutor.InstalledSyncPackageNames()
aurUp, repoUp, err := upList(ctx, warnings, dbExecutor, enableDowngrade, filter)
aurUp, repoUp, err := upList(ctx, cfg, warnings, dbExecutor, enableDowngrade, filter)
os.Stdout = old // restoring the real stdout
if err != nil {

24
query.go
View file

@ -33,15 +33,17 @@ func syncSearch(ctx context.Context, pkgS []string,
}
// SyncInfo serves as a pacman -Si for repo packages and AUR packages.
func syncInfo(ctx context.Context, cmdArgs *parser.Arguments, pkgS []string, dbExecutor db.Executor) error {
func syncInfo(ctx context.Context, cfg *settings.Configuration,
cmdArgs *parser.Arguments, pkgS []string, dbExecutor db.Executor,
) error {
var (
info []aur.Pkg
err error
missing = false
)
pkgS = query.RemoveInvalidTargets(pkgS, config.Runtime.Mode)
aurS, repoS := packageSlices(pkgS, dbExecutor)
pkgS = query.RemoveInvalidTargets(pkgS, cfg.Runtime.Mode)
aurS, repoS := packageSlices(pkgS, cfg, dbExecutor)
if len(aurS) != 0 {
noDB := make([]string, 0, len(aurS))
@ -51,7 +53,7 @@ func syncInfo(ctx context.Context, cmdArgs *parser.Arguments, pkgS []string, dbE
noDB = append(noDB, name)
}
info, err = query.AURInfoPrint(ctx, config.Runtime.AURClient, noDB, config.RequestSplitN)
info, err = query.AURInfoPrint(ctx, cfg.Runtime.AURClient, noDB, cfg.RequestSplitN)
if err != nil {
missing = true
@ -65,8 +67,8 @@ func syncInfo(ctx context.Context, cmdArgs *parser.Arguments, pkgS []string, dbE
arguments.ClearTargets()
arguments.AddTarget(repoS...)
err = config.Runtime.CmdBuilder.Show(config.Runtime.CmdBuilder.BuildPacmanCmd(ctx,
arguments, config.Runtime.Mode, settings.NoConfirm))
err = cfg.Runtime.CmdBuilder.Show(cfg.Runtime.CmdBuilder.BuildPacmanCmd(ctx,
arguments, cfg.Runtime.Mode, settings.NoConfirm))
if err != nil {
return err
}
@ -78,7 +80,7 @@ func syncInfo(ctx context.Context, cmdArgs *parser.Arguments, pkgS []string, dbE
if len(info) != 0 {
for i := range info {
PrintInfo(&info[i], cmdArgs.ExistsDouble("i"))
PrintInfo(cfg, &info[i], cmdArgs.ExistsDouble("i"))
}
}
@ -90,7 +92,7 @@ func syncInfo(ctx context.Context, cmdArgs *parser.Arguments, pkgS []string, dbE
}
// PackageSlices separates an input slice into aur and repo slices.
func packageSlices(toCheck []string, dbExecutor db.Executor) (aurNames, repoNames []string) {
func packageSlices(toCheck []string, config *settings.Configuration, dbExecutor db.Executor) (aurNames, repoNames []string) {
for _, _pkg := range toCheck {
dbName, name := text.SplitDBFromName(_pkg)
@ -203,7 +205,7 @@ func getFolderSize(path string) (size int64) {
}
// Statistics returns statistics about packages installed in system.
func statistics(dbExecutor db.Executor) (res struct {
func statistics(cfg *settings.Configuration, dbExecutor db.Executor) (res struct {
Totaln int
Expln int
TotalSize int64
@ -221,11 +223,11 @@ func statistics(dbExecutor db.Executor) (res struct {
}
res.pacmanCaches = make(map[string]int64)
for _, path := range config.Runtime.PacmanConf.CacheDir {
for _, path := range cfg.Runtime.PacmanConf.CacheDir {
res.pacmanCaches[path] = getFolderSize(path)
}
res.yayCache = getFolderSize(config.BuildDir)
res.yayCache = getFolderSize(cfg.BuildDir)
return
}

30
upgrade.go
View file

@ -36,7 +36,7 @@ func filterUpdateList(list []db.Upgrade, filter upgrade.Filter) []db.Upgrade {
}
// upList returns lists of packages to upgrade from each source.
func upList(ctx context.Context,
func upList(ctx context.Context, cfg *settings.Configuration,
warnings *query.AURWarnings, dbExecutor db.Executor, enableDowngrade bool,
filter upgrade.Filter,
) (aurUp, repoUp upgrade.UpSlice, err error) {
@ -58,7 +58,7 @@ func upList(ctx context.Context,
}
}
if config.Runtime.Mode.AtLeastRepo() {
if cfg.Runtime.Mode.AtLeastRepo() {
text.OperationInfoln(gotext.Get("Searching databases for updates..."))
wg.Add(1)
@ -69,11 +69,11 @@ func upList(ctx context.Context,
}()
}
if config.Runtime.Mode.AtLeastAUR() {
if cfg.Runtime.Mode.AtLeastAUR() {
text.OperationInfoln(gotext.Get("Searching AUR for updates..."))
var _aurdata []aur.Pkg
_aurdata, err = query.AURInfo(ctx, config.Runtime.AURClient, remoteNames, warnings, config.RequestSplitN)
_aurdata, err = query.AURInfo(ctx, cfg.Runtime.AURClient, remoteNames, warnings, cfg.RequestSplitN)
errs.Add(err)
@ -86,19 +86,19 @@ func upList(ctx context.Context,
wg.Add(1)
go func() {
aurUp = upgrade.UpAUR(remote, aurdata, config.TimeUpdate, enableDowngrade)
aurUp = upgrade.UpAUR(remote, aurdata, cfg.TimeUpdate, enableDowngrade)
wg.Done()
}()
if config.Devel {
if cfg.Devel {
text.OperationInfoln(gotext.Get("Checking development packages..."))
wg.Add(1)
go func() {
develUp = upgrade.UpDevel(ctx, remote, aurdata, config.Runtime.VCSStore)
develUp = upgrade.UpDevel(ctx, remote, aurdata, cfg.Runtime.VCSStore)
config.Runtime.VCSStore.CleanOrphans(remote)
cfg.Runtime.VCSStore.CleanOrphans(remote)
wg.Done()
}()
}
@ -185,7 +185,7 @@ func isDevelPackage(pkg alpm.IPackage) bool {
}
// upgradePkgsMenu handles updating the cache and installing updates.
func upgradePkgsMenu(aurUp, repoUp upgrade.UpSlice) (stringset.StringSet, []string, error) {
func upgradePkgsMenu(cfg *settings.Configuration, aurUp, repoUp upgrade.UpSlice) (stringset.StringSet, []string, error) {
ignore := make(stringset.StringSet)
targets := []string{}
@ -194,7 +194,7 @@ func upgradePkgsMenu(aurUp, repoUp upgrade.UpSlice) (stringset.StringSet, []stri
return ignore, nil, nil
}
if !config.UpgradeMenu {
if !cfg.UpgradeMenu {
for _, pkg := range aurUp.Up {
targets = append(targets, pkg.Repository+"/"+pkg.Name)
}
@ -208,11 +208,11 @@ func upgradePkgsMenu(aurUp, repoUp upgrade.UpSlice) (stringset.StringSet, []stri
allUp := upgrade.UpSlice{Up: append(repoUp.Up, aurUp.Up...), Repos: append(repoUp.Repos, aurUp.Repos...)}
fmt.Printf("%s"+text.Bold(" %d ")+"%s\n", text.Bold(text.Cyan("::")), allUpLen, text.Bold(gotext.Get("Packages to upgrade.")))
allUp.Print(config.Runtime.Logger)
allUp.Print(cfg.Runtime.Logger)
text.Infoln(gotext.Get("Packages to exclude") + " (eg: \"1 2 3\", \"1-3\", \"^4\" or repo name):")
numbers, err := text.GetInput(os.Stdin, config.AnswerUpgrade, settings.NoConfirm)
numbers, err := text.GetInput(os.Stdin, cfg.AnswerUpgrade, settings.NoConfirm)
if err != nil {
return nil, nil, err
}
@ -259,12 +259,12 @@ func upgradePkgsMenu(aurUp, repoUp upgrade.UpSlice) (stringset.StringSet, []stri
}
// Targets for sys upgrade.
func sysupgradeTargets(ctx context.Context, dbExecutor db.Executor,
func sysupgradeTargets(ctx context.Context, cfg *settings.Configuration, dbExecutor db.Executor,
enableDowngrade bool,
) (stringset.StringSet, []string, error) {
warnings := query.NewWarnings()
aurUp, repoUp, err := upList(ctx, warnings, dbExecutor, enableDowngrade,
aurUp, repoUp, err := upList(ctx, cfg, warnings, dbExecutor, enableDowngrade,
func(*upgrade.Upgrade) bool { return true })
if err != nil {
return nil, nil, err
@ -272,5 +272,5 @@ func sysupgradeTargets(ctx context.Context, dbExecutor db.Executor,
warnings.Print()
return upgradePkgsMenu(aurUp, repoUp)
return upgradePkgsMenu(cfg, aurUp, repoUp)
}

12
vcs.go
View file

@ -19,15 +19,15 @@ import (
)
// createDevelDB forces yay to create a DB of the existing development packages.
func createDevelDB(ctx context.Context, config *settings.Configuration, dbExecutor db.Executor) error {
func createDevelDB(ctx context.Context, cfg *settings.Configuration, dbExecutor db.Executor) error {
remoteNames := dbExecutor.InstalledRemotePackageNames()
info, err := query.AURInfoPrint(ctx, config.Runtime.AURClient, remoteNames, config.RequestSplitN)
info, err := query.AURInfoPrint(ctx, cfg.Runtime.AURClient, remoteNames, cfg.RequestSplitN)
if err != nil {
return err
}
bases := dep.GetBases(info)
toSkip := pkgbuildsToSkip(bases, stringset.FromSlice(remoteNames))
toSkip := pkgbuildsToSkip(cfg, bases, stringset.FromSlice(remoteNames))
targets := make([]string, 0, len(bases))
pkgBuildDirsByBase := make(map[string]string, len(bases))
@ -37,7 +37,7 @@ func createDevelDB(ctx context.Context, config *settings.Configuration, dbExecut
targets = append(targets, base.Pkgbase())
}
pkgBuildDirsByBase[base.Pkgbase()] = filepath.Join(config.BuildDir, base.Pkgbase())
pkgBuildDirsByBase[base.Pkgbase()] = filepath.Join(cfg.BuildDir, base.Pkgbase())
}
toSkipSlice := toSkip.ToSlice()
@ -48,7 +48,7 @@ func createDevelDB(ctx context.Context, config *settings.Configuration, dbExecut
}
if _, errA := download.AURPKGBUILDRepos(ctx,
config.Runtime.CmdBuilder, targets, config.AURURL, config.BuildDir, false); errA != nil {
cfg.Runtime.CmdBuilder, targets, cfg.AURURL, cfg.BuildDir, false); errA != nil {
return err
}
@ -63,7 +63,7 @@ func createDevelDB(ctx context.Context, config *settings.Configuration, dbExecut
wg.Add(1)
go func(i string, iP int) {
config.Runtime.VCSStore.Update(ctx, srcinfos[i].Packages[iP].Pkgname, srcinfos[i].Source)
cfg.Runtime.VCSStore.Update(ctx, srcinfos[i].Packages[iP].Pkgname, srcinfos[i].Source)
wg.Done()
}(i, iP)
}