chore(yay): lift legacy engine (#2189)

* remove legacy engine

* remove legacy dep handlers

* use prepare for gendb

* remove unused method

* remove aur client old interface

* remove unused menu fns

* remove inactive upgrademenu option

* unexport printInfo

aur_source_test.go

@@ -102,7 +102,7 @@ func Test_downloadPKGBUILDSourceFanout(t *testing.T) {
 				test: t,
 			}
 
-			err := downloadPKGBUILDSourceFanout(context.Background(), cmdBuilder, pkgBuildDirs, false, maxConcurrentDownloads)
+			err := downloadPKGBUILDSourceFanout(context.Background(), cmdBuilder, pkgBuildDirs, true, maxConcurrentDownloads)
 			assert.NoError(t, err)
 			assert.Equal(t, 5, int(cmdBuilder.passes))
 		})

clean.go

@@ -130,7 +130,7 @@ func cleanAUR(ctx context.Context, cfg *settings.Configuration,
 	// Querying the AUR is slow and needs internet so don't do it if we
 	// don't need to.
 	if keepCurrent {
-		info, errInfo := cfg.Runtime.AURCache.Get(ctx, &aur.Query{
+		info, errInfo := cfg.Runtime.AURClient.Get(ctx, &aur.Query{
 			Needles: cachedPackages,
 		})
 		if errInfo != nil {

cmd.go

@@ -91,11 +91,9 @@ Permanent configuration options:
     --cleanmenu           Give the option to clean build PKGBUILDS
     --diffmenu            Give the option to show diffs for build files
     --editmenu            Give the option to edit/view PKGBUILDS
-    --upgrademenu         Show a detailed list of updates with the option to skip any
     --nocleanmenu         Don't clean build PKGBUILDS
     --nodiffmenu          Don't show diffs for build files
     --noeditmenu          Don't edit/view PKGBUILDS
-    --noupgrademenu       Don't show the upgrade menu
     --askremovemake       Ask to remove makedepends after install
     --removemake          Remove makedepends after install
     --noremovemake        Don't remove makedepends after install
@@ -308,10 +306,10 @@ func handleWeb(ctx context.Context, cfg *settings.Configuration, cmdArgs *parser
 	switch {
 	case cmdArgs.ExistsArg("v", "vote"):
 		return handlePackageVote(ctx, cmdArgs.Targets, cfg.Runtime.AURClient,
-			cfg.Runtime.VoteClient, cfg.RequestSplitN, true)
+			cfg.Runtime.VoteClient, true)
 	case cmdArgs.ExistsArg("u", "unvote"):
 		return handlePackageVote(ctx, cmdArgs.Targets, cfg.Runtime.AURClient,
-			cfg.Runtime.VoteClient, cfg.RequestSplitN, false)
+			cfg.Runtime.VoteClient, false)
 	}
 
 	return nil
@@ -319,11 +317,11 @@ func handleWeb(ctx context.Context, cfg *settings.Configuration, cmdArgs *parser
 
 func handleGetpkgbuild(ctx context.Context, cfg *settings.Configuration, cmdArgs *parser.Arguments, dbExecutor download.DBSearcher) error {
 	if cmdArgs.ExistsArg("p", "print") {
-		return printPkgbuilds(dbExecutor, cfg.Runtime.AURCache,
+		return printPkgbuilds(dbExecutor, cfg.Runtime.AURClient,
 			cfg.Runtime.HTTPClient, cmdArgs.Targets, cfg.Mode, cfg.AURURL)
 	}
 
-	return getPkgbuilds(ctx, dbExecutor, cfg.Runtime.AURCache, cfg,
+	return getPkgbuilds(ctx, dbExecutor, cfg.Runtime.AURClient, cfg,
 		cmdArgs.Targets, cmdArgs.ExistsArg("f", "force"))
 }
 
@@ -364,11 +362,7 @@ func handleSync(ctx context.Context, cfg *settings.Configuration, cmdArgs *parse
 	case cmdArgs.ExistsArg("i", "info"):
 		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, cfg, cmdArgs, dbExecutor, false)
+		return syncInstall(ctx, cfg, cmdArgs, dbExecutor)
 	case cmdArgs.ExistsArg("y", "refresh"):
 		return cfg.Runtime.CmdBuilder.Show(cfg.Runtime.CmdBuilder.BuildPacmanCmd(ctx,
 			cmdArgs, cfg.Mode, settings.NoConfirm))
@@ -424,11 +418,7 @@ func displayNumberMenu(ctx context.Context, cfg *settings.Configuration, pkgS []
 		return nil
 	}
 
-	if cfg.NewInstallEngine {
-		return syncInstall(ctx, cfg, cmdArgs, dbExecutor)
-	}
-
-	return install(ctx, cfg, cmdArgs, dbExecutor, true)
+	return syncInstall(ctx, cfg, cmdArgs, dbExecutor)
 }
 
 func syncList(ctx context.Context, cfg *settings.Configuration,

cmd_test.go

@@ -104,15 +104,14 @@ func TestYogurtMenuAURDB(t *testing.T) {
 	}
 	logger := text.NewLogger(io.Discard, os.Stderr, strings.NewReader("1\n"), true, "test")
 	cfg := &settings.Configuration{
-		NewInstallEngine: true,
-		RemoveMake:       "no",
+		RemoveMake: "no",
 		Runtime: &settings.Runtime{
 			Logger:     logger,
 			CmdBuilder: cmdBuilder,
 			VCSStore:   &vcs.Mock{},
 			QueryBuilder: query.NewSourceQueryBuilder(aurCache, logger, "votes", parser.ModeAny, "name",
 				true, false, true),
-			AURCache: aurCache,
+			AURClient: aurCache,
 		},
 	}
 

completions/bash

@@ -72,8 +72,8 @@ _yay() {
           makepkg pacman git gpg gpgflags config requestsplitn sudoloop nosudoloop
           redownload noredownload redownloadall rebuild rebuildall rebuildtree norebuild sortby
           singlelineresults doublelineresults answerclean answerdiff answeredit answerupgrade noanswerclean noanswerdiff
-          noansweredit noanswerupgrade cleanmenu diffmenu editmenu upgrademenu cleanafter nocleanafter
-          nocleanmenu nodiffmenu noupgrademenu provides noprovides pgpfetch nopgpfetch
+          noansweredit noanswerupgrade cleanmenu diffmenu editmenu cleanafter nocleanafter
+          nocleanmenu nodiffmenu provides noprovides pgpfetch nopgpfetch
           useask nouseask combinedupgrade nocombinedupgrade aur repo makepkgconf
           nomakepkgconf askremovemake removemake noremovemake completioninterval aururl aurrpcurl
           searchby batchinstall nobatchinstall'

completions/fish

@@ -216,11 +216,9 @@ complete -c $progname -n "not $noopt" -l noanswerupgrade -d 'Unset the answer fo
 complete -c $progname -n "not $noopt" -l cleanmenu -d 'Give the option to clean build PKGBUILDS' -f
 complete -c $progname -n "not $noopt" -l diffmenu -d 'Give the option to show diffs for build files' -f
 complete -c $progname -n "not $noopt" -l editmenu -d 'Give the option to edit/view PKGBUILDS' -f
-complete -c $progname -n "not $noopt" -l upgrademenu -d 'Show a detailed list of updates with the option to skip any' -f
 complete -c $progname -n "not $noopt" -l nocleanmenu -d 'Do not clean build PKGBUILDS' -f
 complete -c $progname -n "not $noopt" -l nodiffmenu -d 'Do not show diffs for build files' -f
 complete -c $progname -n "not $noopt" -l noeditmenu -d 'Do not edit/view PKGBUILDS' -f
-complete -c $progname -n "not $noopt" -l noupgrademenu -d 'Do not show the upgrade menu' -f
 complete -c $progname -n "not $noopt" -l askremovemake -d 'Ask to remove make deps after install' -f
 complete -c $progname -n "not $noopt" -l removemake -d 'Remove make deps after install' -f
 complete -c $progname -n "not $noopt" -l noremovemake -d 'Do not remove make deps after install' -f

completions/zsh

@@ -70,11 +70,9 @@ _pacman_opts_common=(
 	'--cleanmenu[Give the option to clean build PKGBUILDS]'
 	'--diffmenu[Give the option to show diffs for build files]'
 	'--editmenu[Give the option to edit/view PKGBUILDS]'
-	'--upgrademenu[Show a detailed list of updates with the option to skip any]'
 	"--nocleanmenu[Don't clean build PKGBUILDS]"
 	"--nodiffmenu[Don't show diffs for build files]"
 	"--noeditmenu[Don't edit/view PKGBUILDS]"
-	"--noupgrademenu[Don't show the upgrade menu]"
 	"--askremovemake[Ask to remove makedepends after install]"
 	"--removemake[Remove makedepends after install]"
 	"--noremovemake[Don't remove makedepends after install]"

doc/yay.8

@@ -82,7 +82,7 @@ packages.
 Displays a list of packages matching the search terms and prompts the user on
 which packages to install (yogurt mode).
 
-The first search term is used to query the different sources and 
+The first search term is used to query the different sources and
 the following search terms are used to narrow the search results
 through exact matching.
 
@@ -311,17 +311,6 @@ before building.
 recommended to edit pkgbuild variables unless you know what you are doing.
 
 .TP
-.B \-\-upgrademenu
-Show a detailed list of updates in a similar format to VerbosePkgLists.
-Upgrades can also be skipped using numbers, number ranges or repo names.
-Additionally ^ can be used to invert the selection.
-
-\fBWarning\fR: It is not recommended to skip updates from the repositories as
-this can lead to partial upgrades. This feature is intended to easily skip AUR
-updates on the fly that may be broken or have a long compile time. Ultimately
-it is up to the user what upgrades they skip.
-
-.TP
 .B \-\-nocleanmenu
 Do not show the clean menu.
 
@@ -334,10 +323,6 @@ Do not show the diff menu.
 Do not show the edit menu.
 
 .TP
-.B \-\-noupgrademenu
-Do not show the upgrade menu.
-
-.TP
 .B \-\-askremovemake
 Ask to remove makedepends after installing packages.
 

go.mod

@@ -36,7 +36,6 @@ require github.com/hashicorp/go-multierror v1.1.1
 require (
 	github.com/hashicorp/errwrap v1.1.0 // indirect
 	github.com/mitchellh/mapstructure v1.5.0 // indirect
-	github.com/stretchr/objx v0.5.0 // indirect
 )
 
 go 1.19

go.sum

@@ -17,8 +17,6 @@ github.com/bradleyjkemp/cupaloy v2.3.0+incompatible/go.mod h1:Au1Xw1sgaJ5iSFktEh
 github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
 github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=
 github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
-github.com/deckarep/golang-set/v2 v2.2.0 h1:2pMQd3Soi6qfw7E5MMKaEh5W5ES18bW3AbFFnGl6LgQ=
-github.com/deckarep/golang-set/v2 v2.2.0/go.mod h1:VAky9rY/yGXJOLEDv3OMci+7wtDpOF4IN+y82NBOac4=
 github.com/deckarep/golang-set/v2 v2.3.0 h1:qs18EKUfHm2X9fA50Mr/M5hccg2tNnVqsiBImnyDs0g=
 github.com/deckarep/golang-set/v2 v2.3.0/go.mod h1:VAky9rY/yGXJOLEDv3OMci+7wtDpOF4IN+y82NBOac4=
 github.com/h2non/parth v0.0.0-20190131123155-b4df798d6542 h1:2VTzZjLZBgl62/EtslCrtky5vbi9dd7HrQPQIx6wqiw=
@@ -38,8 +36,6 @@ github.com/mitchellh/mapstructure v1.5.0 h1:jeMsZIYE/09sWLaz43PL7Gy6RuMjD2eJVyua
 github.com/mitchellh/mapstructure v1.5.0/go.mod h1:bFUtVrKA4DC2yAKiSyO/QUcy7e+RRV2QTWOzhPopBRo=
 github.com/nbio/st v0.0.0-20140626010706-e9e8d9816f32 h1:W6apQkHrMkS0Muv8G/TipAy/FJl/rCYT0+EuS8+Z0z4=
 github.com/nbio/st v0.0.0-20140626010706-e9e8d9816f32/go.mod h1:9wM+0iRr9ahx58uYLpLIr5fm8diHn0JbqRycJi6w0Ms=
-github.com/ohler55/ojg v1.17.5 h1:SY6/cdhVzsLinNFIBRNSWhJgihvEWco5Y0TJe46XJ1Y=
-github.com/ohler55/ojg v1.17.5/go.mod h1:7Ghirupn8NC8hSSDpI0gcjorPxj+vSVIONDWfliHR1k=
 github.com/ohler55/ojg v1.18.5 h1:tzn5LJtkSyXowCo8SlGieU0zEc7WF4143Ri9MYlQy7Q=
 github.com/ohler55/ojg v1.18.5/go.mod h1:uHcD1ErbErC27Zhb5Df2jUjbseLLcmOCo6oxSr3jZxo=
 github.com/pkg/errors v0.9.1 h1:FEBLx1zS214owpjy7qsBeixbURkuhQAwrK5UwLGTwt4=
@@ -47,16 +43,11 @@ github.com/pkg/errors v0.9.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINE
 github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
 github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
 github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
-github.com/stretchr/objx v0.4.0/go.mod h1:YvHI0jy2hoMjB+UWwv71VJQ9isScKT/TqJzVSSt89Yw=
 github.com/stretchr/objx v0.5.0 h1:1zr/of2m5FGMsad5YfcqgdqdWrIhu+EBEJRhR1U7z/c=
-github.com/stretchr/objx v0.5.0/go.mod h1:Yh+to48EsGEfYuaHDzXPcE3xhTkx73EhmCGUpEOglKo=
 github.com/stretchr/testify v1.2.2/go.mod h1:a8OnRcib4nhh0OaRAV+Yts87kKdq0PP7pXfy6kDkUVs=
 github.com/stretchr/testify v1.7.0/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg=
 github.com/stretchr/testify v1.7.1/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg=
 github.com/stretchr/testify v1.7.2/go.mod h1:R6va5+xMeoiuVRoj+gSkQ7d3FALtqAAGI1FQKckRals=
-github.com/stretchr/testify v1.8.0/go.mod h1:yNjHg4UonilssWZ8iaSj1OCr/vHnekPRkoO+kdMU+MU=
-github.com/stretchr/testify v1.8.2 h1:+h33VjcLVPDHtOdpUCuF+7gSuG3yGIftsP1YvFihtJ8=
-github.com/stretchr/testify v1.8.2/go.mod h1:w2LPCIKwWwSfY2zedu0+kehJoqGctiVI29o6fzry7u4=
 github.com/stretchr/testify v1.8.3 h1:RP3t2pwF7cMEbC1dqtB6poj3niw/9gnV4Cjg5oW5gtY=
 github.com/stretchr/testify v1.8.3/go.mod h1:sz/lmYIOXD/1dqDmKjjqLyZ2RngseejIcXlSw2iwfAo=
 github.com/yuin/goldmark v1.4.13/go.mod h1:6yULJ656Px+3vBD8DxQVa3kxgyrAnzto9xy5taEt/CY=
@@ -73,22 +64,16 @@ golang.org/x/sys v0.0.0-20201119102817-f84b799fce68/go.mod h1:h1NjWce9XRLGQEsW7w
 golang.org/x/sys v0.0.0-20210615035016-665e8c7367d1/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.0.0-20220520151302-bc2c85ada10a/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.0.0-20220722155257-8c9f86f7a55f/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
-golang.org/x/sys v0.6.0 h1:MVltZSvRTcU2ljQOhs94SXPftV6DCNnZViHeQps87pQ=
-golang.org/x/sys v0.6.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.8.0 h1:EBmGv8NaZBZTWvrbjNoL6HVt+IVy3QDQpJs7VRIw3tU=
 golang.org/x/sys v0.8.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/term v0.0.0-20201126162022-7de9c90e9dd1/go.mod h1:bj7SfCRtBDWHUb9snDiAeCFNEtKQo2Wmx5Cou7ajbmo=
 golang.org/x/term v0.0.0-20210927222741-03fcf44c2211/go.mod h1:jbD1KX2456YbFQfuXm/mYQcufACuNUgVhRMnK/tPxf8=
-golang.org/x/term v0.6.0 h1:clScbb1cHjoCkyRbWwBEUZ5H/tIFu5TAXIqaZD0Gcjw=
-golang.org/x/term v0.6.0/go.mod h1:m6U89DPEgQRMq3DNkDClhWw02AUbt2daBVO4cn4Hv9U=
 golang.org/x/term v0.8.0 h1:n5xxQn2i3PC0yLAbjTpNT85q/Kgzcr2gIoX9OrJUols=
 golang.org/x/term v0.8.0/go.mod h1:xPskH00ivmX89bAKVGSKKtLOWNx2+17Eiy94tnKShWo=
 golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
 golang.org/x/text v0.3.3/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ=
 golang.org/x/text v0.3.7/go.mod h1:u+2+/6zg+i71rQMx5EYifcz6MCKuco9NR6JIITiCfzQ=
 golang.org/x/text v0.3.8/go.mod h1:E6s5w1FMmriuDzIBO73fBruAKo1PCIq6d2Q6DHfQ8WQ=
-golang.org/x/text v0.8.0 h1:57P1ETyNKtuIjB4SRd15iJxuhj8Gc416Y78H3qgMh68=
-golang.org/x/text v0.8.0/go.mod h1:e1OnstbJyHTd6l/uOt8jFFHp6TRDWZR/bV3emEE/zU8=
 golang.org/x/text v0.9.0 h1:2sjJmO8cDvYveuX97RDLsxlyUxLl+GHoLxBiRdHllBE=
 golang.org/x/text v0.9.0/go.mod h1:e1OnstbJyHTd6l/uOt8jFFHp6TRDWZR/bV3emEE/zU8=
 golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=

install.go

@@ -6,28 +6,13 @@ import (
 	"fmt"
 	"os"
 	"path/filepath"
-	"strconv"
 	"strings"
-	"sync"
 
-	alpm "github.com/Jguer/go-alpm/v2"
-	gosrc "github.com/Morganamilo/go-srcinfo"
-	mapset "github.com/deckarep/golang-set/v2"
 	"github.com/leonelquinteros/gotext"
 
-	"github.com/Jguer/yay/v12/pkg/completion"
-	"github.com/Jguer/yay/v12/pkg/db"
-	"github.com/Jguer/yay/v12/pkg/dep"
-	"github.com/Jguer/yay/v12/pkg/download"
-	"github.com/Jguer/yay/v12/pkg/menus"
-	"github.com/Jguer/yay/v12/pkg/pgp"
-	"github.com/Jguer/yay/v12/pkg/query"
 	"github.com/Jguer/yay/v12/pkg/settings"
 	"github.com/Jguer/yay/v12/pkg/settings/exe"
 	"github.com/Jguer/yay/v12/pkg/settings/parser"
-	"github.com/Jguer/yay/v12/pkg/srcinfo"
-	"github.com/Jguer/yay/v12/pkg/stringset"
-	"github.com/Jguer/yay/v12/pkg/text"
 	"github.com/Jguer/yay/v12/pkg/vcs"
 )
 
@@ -84,309 +69,6 @@ func asexp(ctx context.Context,
 	return setPkgReason(ctx, cmdBuilder, mode, cmdArgs, pkgs, true)
 }
 
-// Install handles package installs.
-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(cfg.MFlags, "--nocheck")
-		assumeInstalled = cmdArgs.GetArgs("assume-installed")
-		sysupgradeArg   = cmdArgs.ExistsArg("u", "sysupgrade")
-		refreshArg      = cmdArgs.ExistsArg("y", "refresh")
-		warnings        = query.NewWarnings(cfg.Runtime.Logger)
-	)
-
-	if noDeps {
-		cfg.Runtime.CmdBuilder.AddMakepkgFlag("-d")
-	}
-
-	if cfg.Mode.AtLeastRepo() {
-		if cfg.CombinedUpgrade {
-			if refreshArg {
-				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, cfg, cmdArgs, dbExecutor); errP != nil {
-				return errP
-			}
-		}
-	}
-
-	// we may have done -Sy, our handle now has an old
-	// database.
-	if errRefresh := dbExecutor.RefreshHandle(); errRefresh != nil {
-		return errRefresh
-	}
-
-	remoteNames := dbExecutor.InstalledRemotePackageNames()
-	localNames := dbExecutor.InstalledSyncPackageNames()
-
-	remoteNamesCache := mapset.NewThreadUnsafeSet(remoteNames...)
-	localNamesCache := stringset.FromSlice(localNames)
-
-	requestTargets := cmdArgs.Copy().Targets
-
-	// create the arguments to pass for the repo install
-	arguments := cmdArgs.Copy()
-	arguments.DelArg("asdeps", "asdep")
-	arguments.DelArg("asexplicit", "asexp")
-	arguments.Op = "S"
-	arguments.ClearTargets()
-
-	if cfg.Mode == parser.ModeAUR {
-		arguments.DelArg("u", "sysupgrade")
-	}
-
-	// if we are doing -u also request all packages needing update
-	if sysupgradeArg {
-		var errSysUp error
-
-		requestTargets, errSysUp = addUpgradeTargetsToArgs(ctx, cfg, dbExecutor, cmdArgs, requestTargets, arguments)
-		if errSysUp != nil {
-			return errSysUp
-		}
-	}
-
-	targets := stringset.FromSlice(cmdArgs.Targets)
-
-	dp, err := dep.GetPool(ctx, requestTargets,
-		warnings, dbExecutor, cfg.Runtime.AURClient, cfg.Mode,
-		ignoreProviders, settings.NoConfirm, cfg.Provides, string(cfg.ReBuild), cfg.RequestSplitN, noDeps, noCheck, assumeInstalled)
-	if err != nil {
-		return err
-	}
-
-	if errC := dp.CheckMissing(noDeps, noCheck); errC != nil {
-		return errC
-	}
-
-	if len(dp.Aur) == 0 {
-		if !cfg.CombinedUpgrade {
-			if sysupgradeArg {
-				fmt.Println(gotext.Get(" there is nothing to do"))
-			}
-
-			return nil
-		}
-
-		cmdArgs.Op = "S"
-		cmdArgs.DelArg("y", "refresh")
-
-		if arguments.ExistsArg("ignore") {
-			cmdArgs.CreateOrAppendOption("ignore", arguments.GetArgs("ignore")...)
-		}
-
-		return cfg.Runtime.CmdBuilder.Show(cfg.Runtime.CmdBuilder.BuildPacmanCmd(ctx,
-			cmdArgs, cfg.Mode, settings.NoConfirm))
-	}
-
-	conflicts, errCC := dp.CheckConflicts(cfg.UseAsk, settings.NoConfirm, noDeps)
-	if errCC != nil {
-		return errCC
-	}
-
-	do = dep.GetOrder(dp, noDeps, noCheck)
-
-	for _, pkg := range do.Repo {
-		arguments.AddTarget(pkg.DB().Name() + "/" + pkg.Name())
-	}
-
-	for _, pkg := range dp.Groups {
-		arguments.AddTarget(pkg)
-	}
-
-	if len(do.Aur) == 0 && len(arguments.Targets) == 0 &&
-		(!cmdArgs.ExistsArg("u", "sysupgrade") || cfg.Mode == parser.ModeAUR) {
-		fmt.Println(gotext.Get(" there is nothing to do"))
-		return nil
-	}
-
-	do.Print()
-	fmt.Println()
-
-	pkgbuildDirs := make(map[string]string, len(do.Aur))
-
-	for _, base := range do.Aur {
-		dir := filepath.Join(cfg.BuildDir, base.Pkgbase())
-		pkgbuildDirs[base.Pkgbase()] = dir
-	}
-
-	if cfg.CleanAfter {
-		defer func() {
-			cleanAfter(ctx, cfg, cfg.Runtime.CmdBuilder, pkgbuildDirs)
-		}()
-	}
-
-	if do.HasMake() {
-		switch cfg.RemoveMake {
-		case "yes":
-			defer func() {
-				err = removeMake(ctx, cfg, cfg.Runtime.CmdBuilder, do.GetMake(), cmdArgs)
-			}()
-
-		case "no":
-			break
-		default:
-			if text.ContinueTask(os.Stdin, gotext.Get("Remove make dependencies after install?"), false, settings.NoConfirm) {
-				defer func() {
-					err = removeMake(ctx, cfg, cfg.Runtime.CmdBuilder, do.GetMake(), cmdArgs)
-				}()
-			}
-		}
-	}
-
-	if errCleanMenu := menus.Clean(os.Stdout, cfg.CleanMenu,
-		pkgbuildDirs,
-		remoteNamesCache, settings.NoConfirm, cfg.AnswerClean); errCleanMenu != nil {
-		if errors.As(errCleanMenu, &settings.ErrUserAbort{}) {
-			return errCleanMenu
-		}
-
-		text.Errorln(errCleanMenu)
-	}
-
-	toSkip := pkgbuildsToSkip(cfg, do.Aur, targets)
-	toClone := make([]string, 0, len(do.Aur))
-
-	for _, base := range do.Aur {
-		if !toSkip.Get(base.Pkgbase()) {
-			toClone = append(toClone, base.Pkgbase())
-		}
-	}
-
-	if toSkipSlice := toSkip.ToSlice(); len(toSkipSlice) != 0 {
-		text.OperationInfoln(
-			gotext.Get("PKGBUILD up to date, Skipping (%d/%d): %s",
-				len(toSkipSlice), len(toClone), text.Cyan(strings.Join(toSkipSlice, ", "))))
-	}
-
-	cloned, errA := download.AURPKGBUILDRepos(ctx,
-		cfg.Runtime.CmdBuilder, toClone, cfg.AURURL, cfg.BuildDir, false)
-	if errA != nil {
-		return errA
-	}
-
-	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
-		}
-
-		text.Errorln(errDiffMenu)
-	}
-
-	if errM := mergePkgbuilds(ctx, cfg.Runtime.CmdBuilder, pkgbuildDirs); errM != nil {
-		return errM
-	}
-
-	srcinfos, err = srcinfo.ParseSrcinfoFilesByBase(pkgbuildDirs, true)
-	if err != nil {
-		return err
-	}
-
-	if errEditMenu := menus.Edit(os.Stdout, cfg.Runtime.Logger, cfg.EditMenu, pkgbuildDirs,
-		cfg.Editor, cfg.EditorFlags, remoteNamesCache, srcinfos,
-		settings.NoConfirm, cfg.AnswerEdit); errEditMenu != nil {
-		if errors.As(errEditMenu, &settings.ErrUserAbort{}) {
-			return errEditMenu
-		}
-
-		text.Errorln(errEditMenu)
-	}
-
-	if errI := confirmIncompatibleInstall(srcinfos, dbExecutor); errI != nil {
-		return errI
-	}
-
-	if cfg.PGPFetch {
-		if _, errCPK := pgp.CheckPgpKeys(ctx, pkgbuildDirs, srcinfos, cfg.Runtime.CmdBuilder, settings.NoConfirm); errCPK != nil {
-			return errCPK
-		}
-	}
-
-	if !cfg.CombinedUpgrade {
-		arguments.DelArg("u", "sysupgrade")
-	}
-
-	if len(arguments.Targets) > 0 || arguments.ExistsArg("u") {
-		if errShow := cfg.Runtime.CmdBuilder.Show(cfg.Runtime.CmdBuilder.BuildPacmanCmd(ctx,
-			arguments, cfg.Mode, settings.NoConfirm)); errShow != nil {
-			return errors.New(gotext.Get("error installing repo packages"))
-		}
-
-		deps := make([]string, 0)
-		exp := make([]string, 0)
-
-		for _, pkg := range do.Repo {
-			if !dp.Explicit.Get(pkg.Name()) && !localNamesCache.Get(pkg.Name()) && !remoteNamesCache.Contains(pkg.Name()) {
-				deps = append(deps, pkg.Name())
-
-				continue
-			}
-
-			if cmdArgs.ExistsArg("asdeps", "asdep") && dp.Explicit.Get(pkg.Name()) {
-				deps = append(deps, pkg.Name())
-			} else if cmdArgs.ExistsArg("asexp", "asexplicit") && dp.Explicit.Get(pkg.Name()) {
-				exp = append(exp, pkg.Name())
-			}
-		}
-
-		if errDeps := asdeps(ctx, cfg.Runtime.CmdBuilder, cfg.Mode, cmdArgs, deps); errDeps != nil {
-			return errDeps
-		}
-
-		if errExp := asexp(ctx, cfg.Runtime.CmdBuilder, cfg.Mode, cmdArgs, exp); errExp != nil {
-			return errExp
-		}
-	}
-
-	go func() {
-		_ = completion.Update(ctx, cfg.Runtime.HTTPClient, dbExecutor,
-			cfg.AURURL, cfg.CompletionPath, cfg.CompletionInterval, false)
-	}()
-
-	if errP := downloadPKGBUILDSourceFanout(ctx,
-		cfg.Runtime.CmdBuilder,
-		pkgbuildDirs,
-		true, cfg.MaxConcurrentDownloads); errP != nil {
-		text.Errorln(errP)
-	}
-
-	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, cfg *settings.Configuration, dbExecutor db.Executor,
-	cmdArgs *parser.Arguments, requestTargets []string, arguments *parser.Arguments,
-) ([]string, error) {
-	ignore, targets, errUp := sysupgradeTargets(ctx, cfg, dbExecutor, cmdArgs.ExistsDouble("u", "sysupgrade"))
-	if errUp != nil {
-		return nil, errUp
-	}
-
-	for _, up := range targets {
-		cmdArgs.AddTarget(up)
-		requestTargets = append(requestTargets, up)
-	}
-
-	if len(ignore) > 0 {
-		arguments.CreateOrAppendOption("ignore", ignore.ToSlice()...)
-	}
-
-	return requestTargets, nil
-}
-
 func removeMake(ctx context.Context, config *settings.Configuration,
 	cmdBuilder exe.ICmdBuilder, makeDeps []string, cmdArgs *parser.Arguments,
 ) error {
@@ -410,55 +92,6 @@ func removeMake(ctx context.Context, config *settings.Configuration,
 	return err
 }
 
-func inRepos(dbExecutor db.Executor, pkg string) bool {
-	target := dep.ToTarget(pkg)
-
-	if target.DB == "aur" {
-		return false
-	} else if target.DB != "" {
-		return true
-	}
-
-	previousHideMenus := settings.HideMenus
-	settings.HideMenus = true
-	exists := dbExecutor.SyncSatisfierExists(target.DepString())
-	settings.HideMenus = previousHideMenus
-
-	return exists || len(dbExecutor.PackagesFromGroup(target.Name)) > 0
-}
-
-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 cfg.Mode == parser.ModeRepo {
-		arguments.Targets = targets
-	} else {
-		// separate aur and repo targets
-		for _, target := range targets {
-			if inRepos(dbExecutor, target) {
-				arguments.AddTarget(target)
-			} else {
-				cmdArgs.AddTarget(target)
-			}
-		}
-	}
-
-	if cmdArgs.ExistsArg("y", "refresh") || cmdArgs.ExistsArg("u", "sysupgrade") || len(arguments.Targets) > 0 {
-		if err := cfg.Runtime.CmdBuilder.Show(cfg.Runtime.CmdBuilder.BuildPacmanCmd(ctx,
-			arguments, cfg.Mode, settings.NoConfirm)); err != nil {
-			return errors.New(gotext.Get("error installing repo packages"))
-		}
-	}
-
-	return nil
-}
-
 func earlyRefresh(ctx context.Context, cfg *settings.Configuration, cmdBuilder exe.ICmdBuilder, cmdArgs *parser.Arguments) error {
 	arguments := cmdArgs.Copy()
 	if cfg.CombinedUpgrade {
@@ -473,41 +106,6 @@ func earlyRefresh(ctx context.Context, cfg *settings.Configuration, cmdBuilder e
 		arguments, cfg.Mode, settings.NoConfirm))
 }
 
-func confirmIncompatibleInstall(srcinfos map[string]*gosrc.Srcinfo, dbExecutor db.Executor) error {
-	incompatible := []string{}
-
-	alpmArch, err := dbExecutor.AlpmArchitectures()
-	if err != nil {
-		return err
-	}
-
-nextpkg:
-	for base, srcinfo := range srcinfos {
-		for _, arch := range srcinfo.Arch {
-			if db.ArchIsSupported(alpmArch, arch) {
-				continue nextpkg
-			}
-		}
-		incompatible = append(incompatible, base)
-	}
-
-	if len(incompatible) > 0 {
-		text.Warnln(gotext.Get("The following packages are not compatible with your architecture:"))
-
-		for _, pkg := range incompatible {
-			fmt.Print("  " + text.Cyan(pkg))
-		}
-
-		fmt.Println()
-
-		if !text.ContinueTask(os.Stdin, gotext.Get("Try to build them anyway?"), true, settings.NoConfirm) {
-			return &settings.ErrUserAbort{}
-		}
-	}
-
-	return nil
-}
-
 func parsePackageList(ctx context.Context, cmdBuilder exe.ICmdBuilder,
 	dir string,
 ) (pkgdests map[string]string, pkgVersion string, err error) {
@@ -547,32 +145,6 @@ func parsePackageList(ctx context.Context, cmdBuilder exe.ICmdBuilder,
 	return pkgdests, pkgVersion, nil
 }
 
-func pkgbuildsToSkip(cfg *settings.Configuration, bases []dep.Base, targets stringset.StringSet) stringset.StringSet {
-	toSkip := make(stringset.StringSet)
-
-	for _, base := range bases {
-		isTarget := false
-		for _, pkg := range base {
-			isTarget = isTarget || targets.Get(pkg.Name)
-		}
-
-		if (cfg.ReDownload == "yes" && isTarget) || cfg.ReDownload == "all" {
-			continue
-		}
-
-		dir := filepath.Join(cfg.BuildDir, base.Pkgbase(), ".SRCINFO")
-		pkgbuild, err := gosrc.ParseFile(dir)
-
-		if err == nil {
-			if db.VerCmp(pkgbuild.Version(), base.Version()) >= 0 {
-				toSkip.Set(base.Pkgbase())
-			}
-		}
-	}
-
-	return toSkip
-}
-
 func gitMerge(ctx context.Context, cmdBuilder exe.ICmdBuilder, dir string) error {
 	_, stderr, err := cmdBuilder.Capture(
 		cmdBuilder.BuildGitCmd(ctx,
@@ -602,222 +174,6 @@ func mergePkgbuilds(ctx context.Context, cmdBuilder exe.ICmdBuilder, pkgbuildDir
 	return nil
 }
 
-func buildInstallPkgbuilds(
-	ctx context.Context,
-	cfg *settings.Configuration,
-	cmdArgs *parser.Arguments,
-	dbExecutor db.Executor,
-	dp *dep.Pool,
-	do *dep.Order,
-	srcinfos map[string]*gosrc.Srcinfo,
-	incompatible bool,
-	conflicts stringset.MapStringSet, noDeps, noCheck bool,
-) error {
-	deps := make([]string, 0)
-	exp := make([]string, 0)
-	pkgArchives := make([]string, 0)
-	oldConfirm := settings.NoConfirm
-	settings.NoConfirm = true
-
-	// remotenames: names of all non repo packages on the system
-	remoteNames := dbExecutor.InstalledRemotePackageNames()
-	localNames := dbExecutor.InstalledSyncPackageNames()
-
-	// cache as a stringset. maybe make it return a string set in the first
-	// place
-	remoteNamesCache := stringset.FromSlice(remoteNames)
-	localNamesCache := stringset.FromSlice(localNames)
-
-	for i, base := range do.Aur {
-		pkg := base.Pkgbase()
-		dir := filepath.Join(cfg.BuildDir, pkg)
-		built := true
-
-		satisfied := true
-	all:
-		for _, pkg := range base {
-			for _, dep := range dep.ComputeCombinedDepList(pkg, noDeps, noCheck) {
-				if !dp.AlpmExecutor.LocalSatisfierExists(dep) {
-					satisfied = false
-					text.Warnln(gotext.Get("%s not satisfied, flushing install queue", dep))
-
-					break all
-				}
-			}
-		}
-
-		if !satisfied || !cfg.BatchInstall {
-			text.Debugln("non batch installing archives:", pkgArchives)
-			errArchive := installPkgArchive(ctx, cfg.Runtime.CmdBuilder,
-				cfg.Mode, cfg.Runtime.VCSStore, cmdArgs, pkgArchives, settings.NoConfirm)
-			errReason := setInstallReason(ctx, cfg.Runtime.CmdBuilder, cfg.Mode, cmdArgs, deps, exp)
-
-			deps = make([]string, 0)
-			exp = make([]string, 0)
-			pkgArchives = make([]string, 0) // reset the pkgarchives
-
-			if errArchive != nil || errReason != nil {
-				if i != 0 {
-					go cfg.Runtime.VCSStore.RemovePackages([]string{do.Aur[i-1].String()})
-				}
-
-				if errArchive != nil {
-					return errArchive
-				}
-
-				return errReason
-			}
-		}
-
-		srcInfo := srcinfos[pkg]
-
-		args := []string{"--nobuild", "-fC"}
-
-		if incompatible {
-			args = append(args, "--ignorearch")
-		}
-
-		// pkgver bump
-		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, cfg.Runtime.CmdBuilder, dir)
-		if errList != nil {
-			return errList
-		}
-
-		isExplicit := false
-		for _, b := range base {
-			isExplicit = isExplicit || dp.Explicit.Get(b.Name)
-		}
-
-		if cfg.ReBuild == "no" || (cfg.ReBuild == "yes" && !isExplicit) {
-			for _, split := range base {
-				pkgdest, ok := pkgdests[split.Name]
-				if !ok {
-					return &PkgDestNotInListError{split.Name}
-				}
-
-				if _, errStat := os.Stat(pkgdest); os.IsNotExist(errStat) {
-					built = false
-				} else if errStat != nil {
-					return errStat
-				}
-			}
-		} else {
-			built = false
-		}
-
-		if cmdArgs.ExistsArg("needed") {
-			installed := true
-			for _, split := range base {
-				installed = dp.AlpmExecutor.IsCorrectVersionInstalled(split.Name, pkgVersion)
-			}
-
-			if installed {
-				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))
-				}
-
-				fmt.Fprintln(os.Stdout, gotext.Get("%s is up to date -- skipping", text.Cyan(pkg+"-"+pkgVersion)))
-
-				continue
-			}
-		}
-
-		if built {
-			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))
-			}
-
-			text.Warnln(gotext.Get("%s already made -- skipping build", text.Cyan(pkg+"-"+pkgVersion)))
-		} else {
-			args := []string{"-cf", "--noconfirm", "--noextract", "--noprepare", "--holdver"}
-
-			if incompatible {
-				args = append(args, "--ignorearch")
-			}
-
-			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 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))
-		} else {
-			for _, split := range base {
-				if _, ok := conflicts[split.Name]; ok {
-					settings.NoConfirm = false
-
-					break
-				}
-			}
-		}
-
-		var errAdd error
-
-		for _, split := range base {
-			for suffix, optional := range map[string]bool{"": false, "-debug": true} {
-				deps, exp, pkgArchives, errAdd = doAddTarget(dp, localNamesCache, remoteNamesCache,
-					cmdArgs, pkgdests, deps, exp, split.Name+suffix, optional, pkgArchives)
-				if errAdd != nil {
-					return errAdd
-				}
-			}
-		}
-		text.Debugln("deps:", deps, "exp:", exp, "pkgArchives:", pkgArchives)
-
-		var wg sync.WaitGroup
-
-		for _, pkg := range base {
-			if srcInfo == nil {
-				text.Errorln(gotext.Get("could not find srcinfo for: %s", pkg.Name))
-				break
-			}
-
-			wg.Add(1)
-
-			text.Debugln("checking vcs store for:", pkg.Name)
-			go func(name string) {
-				cfg.Runtime.VCSStore.Update(ctx, name, srcInfo.Source)
-				wg.Done()
-			}(pkg.Name)
-		}
-
-		wg.Wait()
-	}
-
-	text.Debugln("installing archives:", pkgArchives)
-	errArchive := installPkgArchive(ctx, cfg.Runtime.CmdBuilder, cfg.Mode, cfg.Runtime.VCSStore,
-		cmdArgs, pkgArchives, settings.NoConfirm)
-	if errArchive != nil {
-		go cfg.Runtime.VCSStore.RemovePackages([]string{do.Aur[len(do.Aur)-1].String()})
-	}
-
-	errReason := setInstallReason(ctx, cfg.Runtime.CmdBuilder, cfg.Mode, cmdArgs, deps, exp)
-	if errReason != nil {
-		go cfg.Runtime.VCSStore.RemovePackages([]string{do.Aur[len(do.Aur)-1].String()})
-	}
-
-	settings.NoConfirm = oldConfirm
-
-	return nil
-}
-
 func installPkgArchive(ctx context.Context,
 	cmdBuilder exe.ICmdBuilder,
 	mode parser.TargetMode,
@@ -872,40 +228,3 @@ func setInstallReason(ctx context.Context,
 
 	return asexp(ctx, cmdBuilder, mode, cmdArgs, exps)
 }
-
-func doAddTarget(dp *dep.Pool, localNamesCache, remoteNamesCache stringset.StringSet,
-	cmdArgs *parser.Arguments, pkgdests map[string]string,
-	deps, exp []string, name string, optional bool, pkgArchives []string,
-) (newDeps, newExp, newPkgArchives []string, err error) {
-	pkgdest, ok := pkgdests[name]
-	if !ok {
-		if optional {
-			return deps, exp, pkgArchives, nil
-		}
-
-		return deps, exp, pkgArchives, &PkgDestNotInListError{name}
-	}
-
-	if _, errStat := os.Stat(pkgdest); os.IsNotExist(errStat) {
-		if optional {
-			return deps, exp, pkgArchives, nil
-		}
-
-		return deps, exp, pkgArchives, &FindPkgDestError{pkgDest: pkgdest, name: name}
-	}
-
-	pkgArchives = append(pkgArchives, pkgdest)
-
-	switch {
-	case cmdArgs.ExistsArg("asdeps", "asdep"):
-		deps = append(deps, name)
-	case cmdArgs.ExistsArg("asexplicit", "asexp"):
-		exp = append(exp, name)
-	case !dp.Explicit.Get(name) && !localNamesCache.Get(name) && !remoteNamesCache.Get(name):
-		deps = append(deps, name)
-	default:
-		exp = append(exp, name)
-	}
-
-	return deps, exp, pkgArchives, nil
-}

local_install.go

@@ -61,7 +61,7 @@ func installLocalPKGBUILD(
 	cmdArgs *parser.Arguments,
 	dbExecutor db.Executor,
 ) error {
-	aurCache := config.Runtime.AURCache
+	aurCache := config.Runtime.AURClient
 	noCheck := strings.Contains(config.MFlags, "--nocheck")
 
 	if len(cmdArgs.Targets) < 1 {

local_install_test.go

@@ -144,7 +144,7 @@ func TestIntegrationLocalInstall(t *testing.T) {
 			Logger:     NewTestLogger(),
 			CmdBuilder: cmdBuilder,
 			VCSStore:   &vcs.Mock{},
-			AURCache: &mockaur.MockAUR{
+			AURClient: &mockaur.MockAUR{
 				GetFn: func(ctx context.Context, query *aur.Query) ([]aur.Pkg, error) {
 					return []aur.Pkg{}, nil
 				},
@@ -263,7 +263,7 @@ func TestIntegrationLocalInstallMissingDep(t *testing.T) {
 			Logger:     NewTestLogger(),
 			CmdBuilder: cmdBuilder,
 			VCSStore:   &vcs.Mock{},
-			AURCache: &mockaur.MockAUR{
+			AURClient: &mockaur.MockAUR{
 				GetFn: func(ctx context.Context, query *aur.Query) ([]aur.Pkg, error) {
 					return []aur.Pkg{}, nil
 				},
@@ -421,7 +421,7 @@ func TestIntegrationLocalInstallNeeded(t *testing.T) {
 			Logger:     NewTestLogger(),
 			CmdBuilder: cmdBuilder,
 			VCSStore:   &vcs.Mock{},
-			AURCache: &mockaur.MockAUR{
+			AURClient: &mockaur.MockAUR{
 				GetFn: func(ctx context.Context, query *aur.Query) ([]aur.Pkg, error) {
 					return []aur.Pkg{}, nil
 				},
@@ -582,7 +582,7 @@ func TestIntegrationLocalInstallGenerateSRCINFO(t *testing.T) {
 			Logger:     NewTestLogger(),
 			CmdBuilder: cmdBuilder,
 			VCSStore:   &vcs.Mock{},
-			AURCache: &mockaur.MockAUR{
+			AURClient: &mockaur.MockAUR{
 				GetFn: func(ctx context.Context, query *aur.Query) ([]aur.Pkg, error) {
 					return []aur.Pkg{}, nil
 				},
@@ -718,7 +718,7 @@ func TestIntegrationLocalInstallMissingFiles(t *testing.T) {
 			Logger:     NewTestLogger(),
 			CmdBuilder: cmdBuilder,
 			VCSStore:   &vcs.Mock{},
-			AURCache: &mockaur.MockAUR{
+			AURClient: &mockaur.MockAUR{
 				GetFn: func(ctx context.Context, query *aur.Query) ([]aur.Pkg, error) {
 					return []aur.Pkg{}, nil
 				},

main.go

@@ -116,7 +116,7 @@ func main() {
 	cfg.Runtime = runtime
 
 	cfg.Runtime.QueryBuilder = query.NewSourceQueryBuilder(
-		cfg.Runtime.AURCache,
+		cfg.Runtime.AURClient,
 		cfg.Runtime.Logger.Child("mixed.querybuilder"), cfg.SortBy,
 		cfg.Mode, cfg.SearchBy,
 		cfg.BottomUp, cfg.SingleLineResults, cfg.SeparateSources)

pkg/db/executor.go

@@ -47,7 +47,6 @@ type Executor interface {
 	LocalPackage(string) IPackage
 	LocalPackages() []IPackage
 	LocalSatisfierExists(string) bool
-	PackageConflicts(IPackage) []Depend
 	PackageDepends(IPackage) []Depend
 	PackageGroups(IPackage) []string
 	PackageOptionalDepends(IPackage) []Depend

pkg/db/ialpm/alpm.go

@@ -398,11 +398,6 @@ func (ae *AlpmExecutor) PackageProvides(pkg alpm.IPackage) []alpm.Depend {
 	return alpmPackage.Provides().Slice()
 }
 
-func (ae *AlpmExecutor) PackageConflicts(pkg alpm.IPackage) []alpm.Depend {
-	alpmPackage := pkg.(*alpm.Package)
-	return alpmPackage.Conflicts().Slice()
-}
-
 func (ae *AlpmExecutor) PackageGroups(pkg alpm.IPackage) []string {
 	alpmPackage := pkg.(*alpm.Package)
 	return alpmPackage.Groups().Slice()

pkg/dep/base.go

@@ -1,69 +0,0 @@
-package dep
-
-import (
-	aur "github.com/Jguer/yay/v12/pkg/query"
-	"github.com/Jguer/yay/v12/pkg/stringset"
-)
-
-// Base is an AUR base package.
-type Base []*aur.Pkg
-
-// Pkgbase returns the first base package.
-func (b Base) Pkgbase() string {
-	return b[0].PackageBase
-}
-
-// Version returns the first base package version.
-func (b Base) Version() string {
-	return b[0].Version
-}
-
-// URLPath returns the first base package URL.
-func (b Base) URLPath() string {
-	return b[0].URLPath
-}
-
-func (b Base) AnyIsInSet(set stringset.StringSet) bool {
-	for _, pkg := range b {
-		if set.Get(pkg.Name) {
-			return true
-		}
-	}
-
-	return false
-}
-
-// Packages foo and bar from a pkgbase named base would print like so:
-// base (foo bar).
-func (b Base) String() string {
-	pkg := b[0]
-	str := pkg.PackageBase
-
-	if len(b) > 1 || pkg.PackageBase != pkg.Name {
-		str2 := " ("
-		for _, split := range b {
-			str2 += split.Name + " "
-		}
-
-		str2 = str2[:len(str2)-1] + ")"
-
-		str += str2
-	}
-
-	return str
-}
-
-func GetBases(pkgs []aur.Pkg) []Base {
-	basesMap := make(map[string]Base)
-	for i := range pkgs {
-		pkg := &pkgs[i]
-		basesMap[pkg.PackageBase] = append(basesMap[pkg.PackageBase], pkg)
-	}
-
-	bases := make([]Base, 0, len(basesMap))
-	for _, base := range basesMap {
-		bases = append(bases, base)
-	}
-
-	return bases
-}

pkg/dep/dep.go

@@ -5,41 +5,8 @@ import (
 
 	"github.com/Jguer/yay/v12/pkg/db"
 	aur "github.com/Jguer/yay/v12/pkg/query"
-	"github.com/Jguer/yay/v12/pkg/text"
 )
 
-type providers struct {
-	lookfor string
-	Pkgs    []*aur.Pkg
-}
-
-func makeProviders(name string) providers {
-	return providers{
-		name,
-		make([]*aur.Pkg, 0),
-	}
-}
-
-func (q providers) Len() int {
-	return len(q.Pkgs)
-}
-
-func (q providers) Less(i, j int) bool {
-	if q.lookfor == q.Pkgs[i].Name {
-		return true
-	}
-
-	if q.lookfor == q.Pkgs[j].Name {
-		return false
-	}
-
-	return text.LessRunes([]rune(q.Pkgs[i].Name), []rune(q.Pkgs[j].Name))
-}
-
-func (q providers) Swap(i, j int) {
-	q.Pkgs[i], q.Pkgs[j] = q.Pkgs[j], q.Pkgs[i]
-}
-
 func splitDep(dep string) (pkg, mod, ver string) {
 	split := strings.FieldsFunc(dep, func(c rune) bool {
 		match := c == '>' || c == '<' || c == '='
@@ -118,17 +85,3 @@ func satisfiesAur(dep string, pkg *aur.Pkg) bool {
 
 	return false
 }
-
-func satisfiesRepo(dep string, pkg db.IPackage, dbExecutor db.Executor) bool {
-	if pkgSatisfies(pkg.Name(), pkg.Version(), dep) {
-		return true
-	}
-
-	for _, provided := range dbExecutor.PackageProvides(pkg) {
-		if provideSatisfies(provided.String(), dep, pkg.Version()) {
-			return true
-		}
-	}
-
-	return false
-}

pkg/dep/depCheck.go

@@ -1,324 +0,0 @@
-package dep
-
-import (
-	"errors"
-	"fmt"
-	"os"
-	"strings"
-	"sync"
-
-	"github.com/leonelquinteros/gotext"
-
-	"github.com/Jguer/yay/v12/pkg/stringset"
-	"github.com/Jguer/yay/v12/pkg/text"
-)
-
-func (dp *Pool) checkInnerConflict(name, conflict string, conflicts stringset.MapStringSet) {
-	for _, pkg := range dp.Aur {
-		if pkg.Name == name {
-			continue
-		}
-
-		if satisfiesAur(conflict, pkg) {
-			conflicts.Add(name, pkg.Name)
-		}
-	}
-
-	for _, pkg := range dp.Repo {
-		if pkg.Name() == name {
-			continue
-		}
-
-		if satisfiesRepo(conflict, pkg, dp.AlpmExecutor) {
-			conflicts.Add(name, pkg.Name())
-		}
-	}
-}
-
-func (dp *Pool) checkForwardConflict(name, conflict string, conflicts stringset.MapStringSet) {
-	for _, pkg := range dp.AlpmExecutor.LocalPackages() {
-		if pkg.Name() == name || dp.hasPackage(pkg.Name()) {
-			continue
-		}
-
-		if satisfiesRepo(conflict, pkg, dp.AlpmExecutor) {
-			n := pkg.Name()
-			if n != conflict {
-				n += " (" + conflict + ")"
-			}
-
-			conflicts.Add(name, n)
-		}
-	}
-}
-
-func (dp *Pool) checkReverseConflict(name, conflict string, conflicts stringset.MapStringSet) {
-	for _, pkg := range dp.Aur {
-		if pkg.Name == name {
-			continue
-		}
-
-		if satisfiesAur(conflict, pkg) {
-			if name != conflict {
-				name += " (" + conflict + ")"
-			}
-
-			conflicts.Add(pkg.Name, name)
-		}
-	}
-
-	for _, pkg := range dp.Repo {
-		if pkg.Name() == name {
-			continue
-		}
-
-		if satisfiesRepo(conflict, pkg, dp.AlpmExecutor) {
-			if name != conflict {
-				name += " (" + conflict + ")"
-			}
-
-			conflicts.Add(pkg.Name(), name)
-		}
-	}
-}
-
-func (dp *Pool) checkInnerConflicts(conflicts stringset.MapStringSet) {
-	for _, pkg := range dp.Aur {
-		for _, conflict := range pkg.Conflicts {
-			dp.checkInnerConflict(pkg.Name, conflict, conflicts)
-		}
-	}
-
-	for _, pkg := range dp.Repo {
-		for _, conflict := range dp.AlpmExecutor.PackageConflicts(pkg) {
-			dp.checkInnerConflict(pkg.Name(), conflict.String(), conflicts)
-		}
-	}
-}
-
-func (dp *Pool) checkForwardConflicts(conflicts stringset.MapStringSet) {
-	for _, pkg := range dp.Aur {
-		for _, conflict := range pkg.Conflicts {
-			dp.checkForwardConflict(pkg.Name, conflict, conflicts)
-		}
-	}
-
-	for _, pkg := range dp.Repo {
-		for _, conflict := range dp.AlpmExecutor.PackageConflicts(pkg) {
-			dp.checkForwardConflict(pkg.Name(), conflict.String(), conflicts)
-		}
-	}
-}
-
-func (dp *Pool) checkReverseConflicts(conflicts stringset.MapStringSet) {
-	for _, pkg := range dp.AlpmExecutor.LocalPackages() {
-		if dp.hasPackage(pkg.Name()) {
-			continue
-		}
-
-		for _, conflict := range dp.AlpmExecutor.PackageConflicts(pkg) {
-			dp.checkReverseConflict(pkg.Name(), conflict.String(), conflicts)
-		}
-	}
-}
-
-func (dp *Pool) CheckConflicts(useAsk, noConfirm, noDeps bool) (stringset.MapStringSet, error) {
-	conflicts := make(stringset.MapStringSet)
-	if noDeps {
-		return conflicts, nil
-	}
-
-	var wg sync.WaitGroup
-
-	innerConflicts := make(stringset.MapStringSet)
-
-	wg.Add(2)
-
-	text.OperationInfoln(gotext.Get("Checking for conflicts..."))
-
-	go func() {
-		dp.checkForwardConflicts(conflicts)
-		dp.checkReverseConflicts(conflicts)
-		wg.Done()
-	}()
-
-	text.OperationInfoln(gotext.Get("Checking for inner conflicts..."))
-
-	go func() {
-		dp.checkInnerConflicts(innerConflicts)
-		wg.Done()
-	}()
-
-	wg.Wait()
-
-	if len(innerConflicts) != 0 {
-		text.Errorln(gotext.Get("Inner conflicts found:"))
-
-		for name, pkgs := range innerConflicts {
-			str := text.SprintError(name + ":")
-			for pkg := range pkgs {
-				str += " " + text.Cyan(pkg) + ","
-			}
-
-			str = strings.TrimSuffix(str, ",")
-
-			fmt.Println(str)
-		}
-	}
-
-	if len(conflicts) != 0 {
-		text.Errorln(gotext.Get("Package conflicts found:"))
-
-		for name, pkgs := range conflicts {
-			str := text.SprintError(gotext.Get("Installing %s will remove:", text.Cyan(name)))
-			for pkg := range pkgs {
-				str += " " + text.Cyan(pkg) + ","
-			}
-
-			str = strings.TrimSuffix(str, ",")
-
-			fmt.Println(str)
-		}
-	}
-
-	// Add the inner conflicts to the conflicts
-	// These are used to decide what to pass --ask to (if set) or don't pass --noconfirm to
-	// As we have no idea what the order is yet we add every inner conflict to the slice
-	for name, pkgs := range innerConflicts {
-		conflicts[name] = make(stringset.StringSet)
-		for pkg := range pkgs {
-			conflicts[pkg] = make(stringset.StringSet)
-		}
-	}
-
-	if len(conflicts) > 0 {
-		if !useAsk {
-			if noConfirm {
-				return nil, errors.New(gotext.Get("package conflicts can not be resolved with noconfirm, aborting"))
-			}
-
-			text.Errorln(gotext.Get("Conflicting packages will have to be confirmed manually"))
-		}
-	}
-
-	return conflicts, nil
-}
-
-type missing struct {
-	Good    stringset.StringSet
-	Missing map[string][][]string
-}
-
-func (dp *Pool) _checkMissing(dep string, stack []string, missing *missing, noDeps, noCheckDeps bool) {
-	if missing.Good.Get(dep) {
-		return
-	}
-
-	if trees, ok := missing.Missing[dep]; ok {
-		for _, tree := range trees {
-			if stringSliceEqual(tree, stack) {
-				return
-			}
-		}
-
-		missing.Missing[dep] = append(missing.Missing[dep], stack)
-
-		return
-	}
-
-	if aurPkg := dp.findSatisfierAur(dep); aurPkg != nil {
-		missing.Good.Set(dep)
-
-		combinedDepList := ComputeCombinedDepList(aurPkg, noDeps, noCheckDeps)
-		for _, aurDep := range combinedDepList {
-			if dp.AlpmExecutor.LocalSatisfierExists(aurDep) {
-				missing.Good.Set(aurDep)
-				continue
-			}
-
-			dp._checkMissing(aurDep, append(stack, aurPkg.Name), missing, noDeps, noCheckDeps)
-		}
-
-		return
-	}
-
-	if repoPkg := dp.findSatisfierRepo(dep); repoPkg != nil {
-		missing.Good.Set(dep)
-
-		if noDeps {
-			return
-		}
-
-		for _, dep := range dp.AlpmExecutor.PackageDepends(repoPkg) {
-			if dp.AlpmExecutor.LocalSatisfierExists(dep.String()) {
-				missing.Good.Set(dep.String())
-				continue
-			}
-
-			dp._checkMissing(dep.String(), append(stack, repoPkg.Name()), missing, noDeps, noCheckDeps)
-		}
-
-		return
-	}
-
-	missing.Missing[dep] = [][]string{stack}
-}
-
-func stringSliceEqual(a, b []string) bool {
-	if a == nil && b == nil {
-		return true
-	}
-
-	if a == nil || b == nil {
-		return false
-	}
-
-	if len(a) != len(b) {
-		return false
-	}
-
-	for i := 0; i < len(a); i++ {
-		if a[i] != b[i] {
-			return false
-		}
-	}
-
-	return true
-}
-
-func (dp *Pool) CheckMissing(noDeps, noCheckDeps bool) error {
-	missing := &missing{
-		make(stringset.StringSet),
-		make(map[string][][]string),
-	}
-
-	for _, target := range dp.Targets {
-		dp._checkMissing(target.DepString(), make([]string, 0), missing, noDeps, noCheckDeps)
-	}
-
-	if len(missing.Missing) == 0 {
-		return nil
-	}
-
-	text.Errorln(gotext.Get("could not find all required packages:"))
-
-	for dep, trees := range missing.Missing {
-		for _, tree := range trees {
-			fmt.Fprintf(os.Stderr, "\t%s", text.Cyan(dep))
-
-			if len(tree) == 0 {
-				fmt.Fprint(os.Stderr, gotext.Get(" (Target"))
-			} else {
-				fmt.Fprint(os.Stderr, gotext.Get(" (Wanted by: "))
-				for n := 0; n < len(tree)-1; n++ {
-					fmt.Fprint(os.Stderr, text.Cyan(tree[n]), " -> ")
-				}
-				fmt.Fprint(os.Stderr, text.Cyan(tree[len(tree)-1]))
-			}
-
-			fmt.Fprintln(os.Stderr, ")")
-		}
-	}
-
-	return fmt.Errorf("")
-}

pkg/dep/depOrder.go

@@ -1,199 +0,0 @@
-package dep
-
-import (
-	"fmt"
-
-	"github.com/Jguer/yay/v12/pkg/db"
-	aur "github.com/Jguer/yay/v12/pkg/query"
-	"github.com/Jguer/yay/v12/pkg/stringset"
-	"github.com/Jguer/yay/v12/pkg/text"
-)
-
-type Order struct {
-	Aur     []Base
-	Repo    []db.IPackage
-	Runtime stringset.StringSet
-}
-
-func newOrder() *Order {
-	return &Order{
-		make([]Base, 0),
-		make([]db.IPackage, 0),
-		make(stringset.StringSet),
-	}
-}
-
-func GetOrder(dp *Pool, noDeps, noCheckDeps bool) *Order {
-	do := newOrder()
-
-	for _, target := range dp.Targets {
-		dep := target.DepString()
-
-		if aurPkg := dp.Aur[dep]; aurPkg != nil && pkgSatisfies(aurPkg.Name, aurPkg.Version, dep) {
-			do.orderPkgAur(aurPkg, dp, true, noDeps, noCheckDeps)
-		} else if aurPkg := dp.findSatisfierAur(dep); aurPkg != nil {
-			do.orderPkgAur(aurPkg, dp, true, noDeps, noCheckDeps)
-		} else if repoPkg := dp.findSatisfierRepo(dep); repoPkg != nil {
-			do.orderPkgRepo(repoPkg, dp, true)
-		}
-	}
-
-	return do
-}
-
-func (do *Order) orderPkgAur(pkg *aur.Pkg, dp *Pool, runtime, noDeps, noCheckDeps bool) {
-	if runtime {
-		do.Runtime.Set(pkg.Name)
-	}
-
-	delete(dp.Aur, pkg.Name)
-
-	for i, dep := range ComputeCombinedDepList(pkg, noDeps, noCheckDeps) {
-		if aurPkg := dp.findSatisfierAur(dep); aurPkg != nil {
-			do.orderPkgAur(aurPkg, dp, runtime && i == 0, noDeps, noCheckDeps)
-		}
-
-		if repoPkg := dp.findSatisfierRepo(dep); repoPkg != nil {
-			do.orderPkgRepo(repoPkg, dp, runtime && i == 0)
-		}
-	}
-
-	for i, base := range do.Aur {
-		if base.Pkgbase() == pkg.PackageBase {
-			do.Aur[i] = append(base, pkg)
-			return
-		}
-	}
-
-	do.Aur = append(do.Aur, Base{pkg})
-}
-
-func (do *Order) orderPkgRepo(pkg db.IPackage, dp *Pool, runtime bool) {
-	if runtime {
-		do.Runtime.Set(pkg.Name())
-	}
-
-	delete(dp.Repo, pkg.Name())
-
-	for _, dep := range dp.AlpmExecutor.PackageDepends(pkg) {
-		if repoPkg := dp.findSatisfierRepo(dep.String()); repoPkg != nil {
-			do.orderPkgRepo(repoPkg, dp, runtime)
-		}
-	}
-
-	do.Repo = append(do.Repo, pkg)
-}
-
-func (do *Order) HasMake() bool {
-	lenAur := 0
-	for _, base := range do.Aur {
-		lenAur += len(base)
-	}
-
-	return len(do.Runtime) != lenAur+len(do.Repo)
-}
-
-func (do *Order) GetMake() []string {
-	makeOnly := []string{}
-
-	for _, base := range do.Aur {
-		for _, pkg := range base {
-			if !do.Runtime.Get(pkg.Name) {
-				makeOnly = append(makeOnly, pkg.Name)
-			}
-		}
-	}
-
-	for _, pkg := range do.Repo {
-		if !do.Runtime.Get(pkg.Name()) {
-			makeOnly = append(makeOnly, pkg.Name())
-		}
-	}
-
-	return makeOnly
-}
-
-// Print prints repository packages to be downloaded.
-func (do *Order) Print() {
-	repo := ""
-	repoMake := ""
-	aurString := ""
-	aurMake := ""
-
-	repoLen := 0
-	repoMakeLen := 0
-	aurLen := 0
-	aurMakeLen := 0
-
-	for _, pkg := range do.Repo {
-		pkgStr := fmt.Sprintf("  %s-%s", pkg.Name(), pkg.Version())
-		if do.Runtime.Get(pkg.Name()) {
-			repo += pkgStr
-			repoLen++
-		} else {
-			repoMake += pkgStr
-			repoMakeLen++
-		}
-	}
-
-	for _, base := range do.Aur {
-		pkg := base.Pkgbase()
-		pkgStr := "  " + pkg + "-" + base[0].Version
-		pkgStrMake := pkgStr
-
-		push := false
-		pushMake := false
-
-		switch {
-		case len(base) > 1, pkg != base[0].Name:
-			pkgStr += " ("
-			pkgStrMake += " ("
-
-			for _, split := range base {
-				if do.Runtime.Get(split.Name) {
-					pkgStr += split.Name + " "
-					aurLen++
-
-					push = true
-				} else {
-					pkgStrMake += split.Name + " "
-					aurMakeLen++
-					pushMake = true
-				}
-			}
-
-			pkgStr = pkgStr[:len(pkgStr)-1] + ")"
-			pkgStrMake = pkgStrMake[:len(pkgStrMake)-1] + ")"
-		case do.Runtime.Get(base[0].Name):
-			aurLen++
-
-			push = true
-		default:
-			aurMakeLen++
-
-			pushMake = true
-		}
-
-		if push {
-			aurString += pkgStr
-		}
-
-		if pushMake {
-			aurMake += pkgStrMake
-		}
-	}
-
-	printDownloads("Repo", repoLen, repo)
-	printDownloads("Repo Make", repoMakeLen, repoMake)
-	printDownloads("Aur", aurLen, aurString)
-	printDownloads("Aur Make", aurMakeLen, aurMake)
-}
-
-func printDownloads(repoName string, length int, packages string) {
-	if length < 1 {
-		return
-	}
-
-	repoInfo := fmt.Sprintf(text.Bold(text.Blue("[%s:%d]")), repoName, length)
-	fmt.Println(repoInfo + text.Cyan(packages))
-}

pkg/dep/depPool.go

@@ -1,546 +0,0 @@
-package dep
-
-import (
-	"context"
-	"fmt"
-	"os"
-	"sort"
-	"strconv"
-	"sync"
-
-	"github.com/Jguer/aur"
-	"github.com/Jguer/aur/rpc"
-	alpm "github.com/Jguer/go-alpm/v2"
-	"github.com/leonelquinteros/gotext"
-
-	"github.com/Jguer/yay/v12/pkg/db"
-	"github.com/Jguer/yay/v12/pkg/query"
-	"github.com/Jguer/yay/v12/pkg/settings"
-	"github.com/Jguer/yay/v12/pkg/settings/parser"
-	"github.com/Jguer/yay/v12/pkg/stringset"
-	"github.com/Jguer/yay/v12/pkg/text"
-)
-
-type Pool struct {
-	Targets      []Target
-	Explicit     stringset.StringSet
-	Repo         map[string]db.IPackage
-	Aur          map[string]*query.Pkg
-	AurCache     map[string]*query.Pkg
-	Groups       []string
-	AlpmExecutor db.Executor
-	Warnings     *query.AURWarnings
-	aurClient    rpc.ClientInterface
-}
-
-func newPool(dbExecutor db.Executor, aurClient rpc.ClientInterface) *Pool {
-	dp := &Pool{
-		Targets:      []Target{},
-		Explicit:     map[string]struct{}{},
-		Repo:         map[string]alpm.IPackage{},
-		Aur:          map[string]*aur.Pkg{},
-		AurCache:     map[string]*aur.Pkg{},
-		Groups:       []string{},
-		AlpmExecutor: dbExecutor,
-		Warnings:     nil,
-		aurClient:    aurClient,
-	}
-
-	return dp
-}
-
-// Includes db/ prefixes and group installs.
-func (dp *Pool) ResolveTargets(ctx context.Context, pkgs []string,
-	mode parser.TargetMode,
-	ignoreProviders, noConfirm, provides bool, rebuild string, splitN int, noDeps, noCheckDeps bool, assumeInstalled []string,
-) error {
-	// RPC requests are slow
-	// Combine as many AUR package requests as possible into a single RPC call
-	aurTargets := make(stringset.StringSet)
-
-	pkgs = query.RemoveInvalidTargets(pkgs, mode)
-
-	for _, pkg := range pkgs {
-		target := ToTarget(pkg)
-
-		// skip targets already satisfied
-		// even if the user enters db/pkg and aur/pkg the latter will
-		// still get skipped even if it's from a different database to
-		// the one specified
-		// this is how pacman behaves
-		if dp.hasPackage(target.DepString()) || isInAssumeInstalled(target.DepString(), assumeInstalled) {
-			continue
-		}
-
-		var foundPkg db.IPackage
-
-		// aur/ prefix means we only check the aur
-		if target.DB == "aur" || mode == parser.ModeAUR {
-			dp.Targets = append(dp.Targets, target)
-			aurTargets.Set(target.DepString())
-
-			continue
-		}
-
-		// If there's a different prefix only look in that repo
-		if target.DB != "" {
-			foundPkg = dp.AlpmExecutor.SatisfierFromDB(target.DepString(), target.DB)
-		} else {
-			// otherwise find it in any repo
-			foundPkg = dp.AlpmExecutor.SyncSatisfier(target.DepString())
-		}
-
-		if foundPkg != nil {
-			dp.Targets = append(dp.Targets, target)
-			dp.Explicit.Set(foundPkg.Name())
-			dp.ResolveRepoDependency(foundPkg, noDeps)
-
-			continue
-		} else {
-			// check for groups
-			// currently we don't resolve the packages in a group
-			// only check if the group exists
-			// would be better to check the groups from singleDB if
-			// the user specified a db but there's no easy way to do
-			// it without making alpm_lists so don't bother for now
-			// db/group is probably a rare use case
-			groupPackages := dp.AlpmExecutor.PackagesFromGroup(target.Name)
-			if len(groupPackages) > 0 {
-				dp.Groups = append(dp.Groups, target.String())
-				for _, pkg := range groupPackages {
-					dp.Explicit.Set(pkg.Name())
-				}
-				continue
-			}
-		}
-
-		// if there was no db prefix check the aur
-		if target.DB == "" {
-			aurTargets.Set(target.DepString())
-		}
-
-		dp.Targets = append(dp.Targets, target)
-	}
-
-	if len(aurTargets) > 0 && mode.AtLeastAUR() {
-		return dp.resolveAURPackages(ctx, aurTargets, true, ignoreProviders,
-			noConfirm, provides, rebuild, splitN, noDeps, noCheckDeps)
-	}
-
-	return nil
-}
-
-// Pseudo provides finder.
-// Try to find provides by performing a search of the package name
-// This effectively performs -Ss on each package
-// then runs -Si on each result to cache the information.
-//
-// For example if you were to -S yay then yay -Ss would give:
-// yay-git yay-bin yay realyog pacui pacui-git ruby-yard
-// These packages will all be added to the cache in case they are needed later
-// Ofcouse only the first three packages provide yay, the rest are just false
-// positives.
-//
-// This method increases dependency resolve time.
-func (dp *Pool) findProvides(ctx context.Context, pkgs stringset.StringSet) error {
-	var (
-		mux sync.Mutex
-		wg  sync.WaitGroup
-	)
-
-	doSearch := func(pkg string) {
-		defer wg.Done()
-
-		var (
-			err     error
-			results []query.Pkg
-		)
-
-		results, err = dp.aurClient.Search(ctx, pkg, aur.Provides)
-		if err != nil {
-			return
-		}
-
-		for iR := range results {
-			mux.Lock()
-			if _, ok := dp.AurCache[results[iR].Name]; !ok {
-				pkgs.Set(results[iR].Name)
-			}
-			mux.Unlock()
-		}
-	}
-
-	for pkg := range pkgs {
-		if dp.AlpmExecutor.LocalPackage(pkg) != nil {
-			continue
-		}
-
-		wg.Add(1)
-
-		text.Debugln("AUR RPC Search:", pkg)
-
-		go doSearch(pkg)
-	}
-
-	wg.Wait()
-
-	return nil
-}
-
-func (dp *Pool) cacheAURPackages(ctx context.Context, _pkgs stringset.StringSet, provides bool, splitN int) error {
-	pkgs := _pkgs.Copy()
-	toQuery := make([]string, 0)
-
-	for pkg := range pkgs {
-		if _, ok := dp.AurCache[pkg]; ok {
-			pkgs.Remove(pkg)
-		}
-	}
-
-	if len(pkgs) == 0 {
-		return nil
-	}
-
-	if provides {
-		err := dp.findProvides(ctx, pkgs)
-		if err != nil {
-			return err
-		}
-	}
-
-	for pkg := range pkgs {
-		if _, ok := dp.AurCache[pkg]; !ok {
-			name, _, ver := splitDep(pkg)
-			if ver != "" {
-				toQuery = append(toQuery, name, name+"-"+ver)
-			} else {
-				toQuery = append(toQuery, name)
-			}
-		}
-	}
-
-	info, err := query.AURInfo(ctx, dp.aurClient, toQuery, dp.Warnings, splitN)
-	if err != nil {
-		return err
-	}
-
-	for i := range info {
-		// Dump everything in cache just in case we need it later
-		pkg := &info[i]
-		dp.AurCache[pkg.Name] = pkg
-	}
-
-	return nil
-}
-
-// Compute dependency lists used in Package dep searching and ordering.
-// Order sensitive TOFIX.
-func ComputeCombinedDepList(pkg *aur.Pkg, noDeps, noCheckDeps bool) []string {
-	combinedDepList := make([]string, 0, len(pkg.Depends)+len(pkg.MakeDepends)+len(pkg.CheckDepends))
-
-	if !noDeps {
-		combinedDepList = append(combinedDepList, pkg.Depends...)
-	}
-
-	combinedDepList = append(combinedDepList, pkg.MakeDepends...)
-
-	if !noCheckDeps {
-		combinedDepList = append(combinedDepList, pkg.CheckDepends...)
-	}
-
-	return combinedDepList
-}
-
-func (dp *Pool) resolveAURPackages(ctx context.Context,
-	pkgs stringset.StringSet,
-	explicit, ignoreProviders, noConfirm, provides bool,
-	rebuild string, splitN int, noDeps, noCheckDeps bool,
-) error {
-	newPackages := make(stringset.StringSet)
-	newAURPackages := make(stringset.StringSet)
-
-	err := dp.cacheAURPackages(ctx, pkgs, provides, splitN)
-	if err != nil {
-		return err
-	}
-
-	if len(pkgs) == 0 {
-		return nil
-	}
-
-	for name := range pkgs {
-		_, ok := dp.Aur[name]
-		if ok {
-			continue
-		}
-
-		pkg := dp.findSatisfierAurCache(name, ignoreProviders, noConfirm, provides)
-		if pkg == nil {
-			continue
-		}
-
-		if explicit {
-			dp.Explicit.Set(pkg.Name)
-		}
-
-		dp.Aur[pkg.Name] = pkg
-
-		combinedDepList := ComputeCombinedDepList(pkg, noDeps, noCheckDeps)
-		for _, dep := range combinedDepList {
-			newPackages.Set(dep)
-		}
-	}
-
-	for dep := range newPackages {
-		if dp.hasSatisfier(dep) {
-			continue
-		}
-
-		isInstalled := dp.AlpmExecutor.LocalSatisfierExists(dep)
-		hm := settings.HideMenus
-		settings.HideMenus = isInstalled
-		repoPkg := dp.AlpmExecutor.SyncSatisfier(dep) // has satisfier in repo: fetch it
-		settings.HideMenus = hm
-
-		if isInstalled && (rebuild != "tree" || repoPkg != nil) {
-			continue
-		}
-
-		if repoPkg != nil {
-			dp.ResolveRepoDependency(repoPkg, false)
-			continue
-		}
-
-		// assume it's in the aur
-		// ditch the versioning because the RPC can't handle it
-		newAURPackages.Set(dep)
-	}
-
-	err = dp.resolveAURPackages(ctx, newAURPackages, false, ignoreProviders,
-		noConfirm, provides, rebuild, splitN, noDeps, noCheckDeps)
-
-	return err
-}
-
-func (dp *Pool) ResolveRepoDependency(pkg db.IPackage, noDeps bool) {
-	dp.Repo[pkg.Name()] = pkg
-
-	if noDeps {
-		return
-	}
-
-	for _, dep := range dp.AlpmExecutor.PackageDepends(pkg) {
-		if dp.hasSatisfier(dep.String()) {
-			continue
-		}
-
-		// has satisfier installed: skip
-		if dp.AlpmExecutor.LocalSatisfierExists(dep.String()) {
-			continue
-		}
-
-		// has satisfier in repo: fetch it
-		if repoPkg := dp.AlpmExecutor.SyncSatisfier(dep.String()); repoPkg != nil {
-			dp.ResolveRepoDependency(repoPkg, noDeps)
-		}
-	}
-}
-
-func GetPool(ctx context.Context, pkgs []string,
-	warnings *query.AURWarnings,
-	dbExecutor db.Executor,
-	aurClient rpc.ClientInterface,
-	mode parser.TargetMode,
-	ignoreProviders, noConfirm, provides bool,
-	rebuild string, splitN int, noDeps bool, noCheckDeps bool, assumeInstalled []string,
-) (*Pool, error) {
-	dp := newPool(dbExecutor, aurClient)
-
-	dp.Warnings = warnings
-	err := dp.ResolveTargets(ctx, pkgs, mode, ignoreProviders, noConfirm, provides,
-		rebuild, splitN, noDeps, noCheckDeps, assumeInstalled)
-
-	return dp, err
-}
-
-func (dp *Pool) findSatisfierAur(dep string) *query.Pkg {
-	for _, pkg := range dp.Aur {
-		if satisfiesAur(dep, pkg) {
-			return pkg
-		}
-	}
-
-	return nil
-}
-
-// This is mostly used to promote packages from the cache
-// to the Install list
-// Provide a pacman style provider menu if there's more than one candidate
-// This acts slightly differently from Pacman, It will give
-// a menu even if a package with a matching name exists. I believe this
-// method is better because most of the time you are choosing between
-// foo and foo-git.
-// Using Pacman's ways trying to install foo would never give you
-// a menu.
-// TODO: maybe intermix repo providers in the menu.
-func (dp *Pool) findSatisfierAurCache(dep string, ignoreProviders, noConfirm, provides bool) *query.Pkg {
-	depName, _, _ := splitDep(dep)
-	seen := make(stringset.StringSet)
-	providerSlice := makeProviders(depName)
-
-	if dp.AlpmExecutor.LocalPackage(depName) != nil {
-		if pkg, ok := dp.AurCache[dep]; ok && pkgSatisfies(pkg.Name, pkg.Version, dep) {
-			return pkg
-		}
-	}
-
-	if ignoreProviders {
-		for _, pkg := range dp.AurCache {
-			if pkgSatisfies(pkg.Name, pkg.Version, dep) {
-				for _, target := range dp.Targets {
-					if target.Name == pkg.Name {
-						return pkg
-					}
-				}
-			}
-		}
-	}
-
-	for _, pkg := range dp.AurCache {
-		if seen.Get(pkg.Name) {
-			continue
-		}
-
-		if pkgSatisfies(pkg.Name, pkg.Version, dep) {
-			providerSlice.Pkgs = append(providerSlice.Pkgs, pkg)
-			seen.Set(pkg.Name)
-
-			continue
-		}
-
-		for _, provide := range pkg.Provides {
-			if provideSatisfies(provide, dep, pkg.Version) {
-				providerSlice.Pkgs = append(providerSlice.Pkgs, pkg)
-				seen.Set(pkg.Name)
-
-				continue
-			}
-		}
-	}
-
-	if !provides && providerSlice.Len() >= 1 {
-		return providerSlice.Pkgs[0]
-	}
-
-	if providerSlice.Len() == 1 {
-		return providerSlice.Pkgs[0]
-	}
-
-	if providerSlice.Len() > 1 {
-		sort.Sort(providerSlice)
-		return providerMenu(dep, providerSlice, noConfirm)
-	}
-
-	return nil
-}
-
-func (dp *Pool) findSatisfierRepo(dep string) db.IPackage {
-	for _, pkg := range dp.Repo {
-		if satisfiesRepo(dep, pkg, dp.AlpmExecutor) {
-			return pkg
-		}
-	}
-
-	return nil
-}
-
-func (dp *Pool) hasSatisfier(dep string) bool {
-	return dp.findSatisfierRepo(dep) != nil || dp.findSatisfierAur(dep) != nil
-}
-
-func (dp *Pool) hasPackage(name string) bool {
-	for _, pkg := range dp.Repo {
-		if pkg.Name() == name {
-			return true
-		}
-	}
-
-	for _, pkg := range dp.Aur {
-		if pkg.Name == name {
-			return true
-		}
-	}
-
-	for _, pkg := range dp.Groups {
-		if pkg == name {
-			return true
-		}
-	}
-
-	return false
-}
-
-func isInAssumeInstalled(name string, assumeInstalled []string) bool {
-	for _, pkgAndVersion := range assumeInstalled {
-		assumeName, _, _ := splitDep(pkgAndVersion)
-
-		depName, _, _ := splitDep(name)
-		if assumeName == depName {
-			return true
-		}
-	}
-
-	return false
-}
-
-func providerMenu(dep string, providers providers, noConfirm bool) *query.Pkg {
-	size := providers.Len()
-
-	str := text.Bold(gotext.Get("There are %d providers available for %s:", size, dep))
-	str += "\n"
-
-	size = 1
-	str += text.SprintOperationInfo(gotext.Get("Repository AUR"), "\n    ")
-
-	for _, pkg := range providers.Pkgs {
-		str += fmt.Sprintf("%d) %s ", size, pkg.Name)
-		size++
-	}
-
-	text.OperationInfoln(str)
-
-	for {
-		fmt.Println(gotext.Get("\nEnter a number (default=1): "))
-
-		if noConfirm {
-			fmt.Println("1")
-			return providers.Pkgs[0]
-		}
-
-		numberBuf, err := text.GetInput(os.Stdin, "", false)
-		if err != nil {
-			fmt.Fprintln(os.Stderr, err)
-
-			break
-		}
-
-		if numberBuf == "" {
-			return providers.Pkgs[0]
-		}
-
-		num, err := strconv.Atoi(numberBuf)
-		if err != nil {
-			text.Errorln(gotext.Get("invalid number: %s", numberBuf))
-			continue
-		}
-
-		if num < 1 || num >= size {
-			text.Errorln(gotext.Get("invalid value: %d is not between %d and %d", num, 1, size-1))
-			continue
-		}
-
-		return providers.Pkgs[num-1]
-	}
-
-	return nil
-}

pkg/menus/clean_menu.go

@@ -3,7 +3,6 @@ package menus
 
 import (
 	"context"
-	"fmt"
 	"io"
 	"os"
 
@@ -75,42 +74,3 @@ func CleanFn(ctx context.Context, config *settings.Configuration, w io.Writer, p
 
 	return nil
 }
-
-func Clean(w io.Writer, cleanMenuOption bool, pkgbuildDirs map[string]string,
-	installed mapset.Set[string], noConfirm bool, answerClean string,
-) error {
-	if !(cleanMenuOption && anyExistInCache(pkgbuildDirs)) {
-		return nil
-	}
-
-	skipFunc := func(pkg string) bool {
-		dir := pkgbuildDirs[pkg]
-		if _, err := os.Stat(dir); os.IsNotExist(err) {
-			return true
-		}
-
-		return false
-	}
-
-	bases := make([]string, 0, len(pkgbuildDirs))
-	for pkg := range pkgbuildDirs {
-		bases = append(bases, pkg)
-	}
-
-	toClean, errClean := selectionMenu(w, pkgbuildDirs, bases, installed, gotext.Get("Packages to cleanBuild?"),
-		noConfirm, answerClean, skipFunc)
-	if errClean != nil {
-		return errClean
-	}
-
-	for i, base := range toClean {
-		dir := pkgbuildDirs[base]
-		text.OperationInfoln(gotext.Get("Deleting (%d/%d): %s", i+1, len(toClean), text.Cyan(dir)))
-
-		if err := os.RemoveAll(dir); err != nil {
-			fmt.Fprintln(os.Stderr, err)
-		}
-	}
-
-	return nil
-}

pkg/menus/diff_menu.go

@@ -145,42 +145,6 @@ func updatePkgbuildSeenRef(ctx context.Context, cmdBuilder exe.ICmdBuilder, pkgb
 	return errMulti.Return()
 }
 
-func Diff(ctx context.Context, cmdBuilder exe.ICmdBuilder, w io.Writer,
-	pkgbuildDirs map[string]string, diffMenuOption bool,
-	installed mapset.Set[string], cloned map[string]bool, noConfirm bool, diffDefaultAnswer string,
-) error {
-	if !diffMenuOption {
-		return nil
-	}
-
-	bases := make([]string, 0, len(pkgbuildDirs))
-	for base := range pkgbuildDirs {
-		bases = append(bases, base)
-	}
-
-	toDiff, errMenu := selectionMenu(w, pkgbuildDirs, bases, installed, gotext.Get("Diffs to show?"),
-		noConfirm, diffDefaultAnswer, nil)
-	if errMenu != nil || len(toDiff) == 0 {
-		return errMenu
-	}
-
-	if errD := showPkgbuildDiffs(ctx, cmdBuilder, pkgbuildDirs, toDiff); errD != nil {
-		return errD
-	}
-
-	fmt.Println()
-
-	if !text.ContinueTask(os.Stdin, gotext.Get("Proceed with install?"), true, false) {
-		return settings.ErrUserAbort{}
-	}
-
-	if errUpd := updatePkgbuildSeenRef(ctx, cmdBuilder, pkgbuildDirs, toDiff); errUpd != nil {
-		return errUpd
-	}
-
-	return nil
-}
-
 func DiffFn(ctx context.Context, config *settings.Configuration, w io.Writer, pkgbuildDirsByBase map[string]string) error {
 	if len(pkgbuildDirsByBase) == 0 {
 		return nil // no work to do

pkg/menus/edit_menu.go

@@ -4,7 +4,6 @@ package menus
 import (
 	"context"
 	"errors"
-	"fmt"
 	"io"
 	"os"
 	"os/exec"
@@ -114,38 +113,6 @@ func editPkgbuilds(log *text.Logger, pkgbuildDirs map[string]string, bases []str
 	return nil
 }
 
-func Edit(w io.Writer, log *text.Logger, editMenuOption bool, pkgbuildDirs map[string]string, editorConfig,
-	editorFlags string, installed mapset.Set[string], srcinfos map[string]*gosrc.Srcinfo,
-	noConfirm bool, editDefaultAnswer string,
-) error {
-	if !editMenuOption {
-		return nil
-	}
-
-	bases := make([]string, 0, len(pkgbuildDirs))
-	for pkg := range pkgbuildDirs {
-		bases = append(bases, pkg)
-	}
-
-	toEdit, errMenu := selectionMenu(w, pkgbuildDirs, bases,
-		installed, gotext.Get("PKGBUILDs to edit?"), noConfirm, editDefaultAnswer, nil)
-	if errMenu != nil || len(toEdit) == 0 {
-		return errMenu
-	}
-
-	if errEdit := editPkgbuilds(log, pkgbuildDirs, toEdit, editorConfig, editorFlags, srcinfos, noConfirm); errEdit != nil {
-		return errEdit
-	}
-
-	fmt.Println()
-
-	if !text.ContinueTask(os.Stdin, gotext.Get("Proceed with install?"), true, false) {
-		return settings.ErrUserAbort{}
-	}
-
-	return nil
-}
-
 func EditFn(ctx context.Context, cfg *settings.Configuration, w io.Writer,
 	pkgbuildDirsByBase map[string]string,
 ) error {

pkg/query/aur_info.go

@@ -1,101 +0,0 @@
-package query
-
-import (
-	"context"
-	"sync"
-
-	"github.com/Jguer/aur"
-	"github.com/Jguer/aur/rpc"
-	"github.com/leonelquinteros/gotext"
-
-	"github.com/Jguer/yay/v12/pkg/intrange"
-	"github.com/Jguer/yay/v12/pkg/multierror"
-	"github.com/Jguer/yay/v12/pkg/text"
-)
-
-type Pkg = aur.Pkg
-
-// Queries the aur for information about specified packages.
-// All packages should be queried in a single aur request except when the number
-// of packages exceeds the number set in config.RequestSplitN.
-// If the number does exceed config.RequestSplitN multiple aur requests will be
-// performed concurrently.
-func AURInfo(ctx context.Context, aurClient rpc.ClientInterface, names []string, warnings *AURWarnings, splitN int) ([]Pkg, error) {
-	info := make([]Pkg, 0, len(names))
-	seen := make(map[string]int)
-
-	var (
-		mux  sync.Mutex
-		wg   sync.WaitGroup
-		errs multierror.MultiError
-	)
-
-	makeRequest := func(n, max int) {
-		defer wg.Done()
-
-		text.Debugln("AUR RPC:", names[n:max])
-
-		tempInfo, requestErr := aurClient.Info(ctx, names[n:max])
-		if requestErr != nil {
-			errs.Add(requestErr)
-			return
-		}
-
-		mux.Lock()
-		info = append(info, tempInfo...)
-		mux.Unlock()
-	}
-
-	for n := 0; n < len(names); n += splitN {
-		max := intrange.Min(len(names), n+splitN)
-
-		wg.Add(1)
-
-		go makeRequest(n, max)
-	}
-
-	wg.Wait()
-
-	if err := errs.Return(); err != nil {
-		return info, err
-	}
-
-	for k := range info {
-		seen[info[k].Name] = k
-	}
-
-	for _, name := range names {
-		i, ok := seen[name]
-		if !ok && !warnings.Ignore.Get(name) {
-			warnings.Missing = append(warnings.Missing, name)
-			continue
-		}
-
-		pkg := info[i]
-
-		if pkg.Maintainer == "" && !warnings.Ignore.Get(name) {
-			warnings.Orphans = append(warnings.Orphans, name)
-		}
-
-		if pkg.OutOfDate != 0 && !warnings.Ignore.Get(name) {
-			warnings.OutOfDate = append(warnings.OutOfDate, name)
-		}
-	}
-
-	return info, nil
-}
-
-func AURInfoPrint(ctx context.Context, aurClient rpc.ClientInterface, names []string, splitN int) ([]Pkg, error) {
-	text.OperationInfoln(gotext.Get("Querying AUR..."))
-
-	warnings := NewWarnings(nil)
-
-	info, err := AURInfo(ctx, aurClient, names, warnings, splitN)
-	if err != nil {
-		return info, err
-	}
-
-	warnings.Print()
-
-	return info, nil
-}

pkg/query/types.go

@@ -12,6 +12,8 @@ import (
 	"github.com/Jguer/yay/v12/pkg/text"
 )
 
+type Pkg = aur.Pkg
+
 func getSearchBy(value string) aur.By {
 	switch value {
 	case "name":

pkg/settings/args.go

@@ -169,10 +169,6 @@ func (c *Configuration) handleOption(option, value string) bool {
 		c.PGPFetch = true
 	case "nopgpfetch":
 		c.PGPFetch = false
-	case "upgrademenu":
-		c.UpgradeMenu = true
-	case "noupgrademenu":
-		c.UpgradeMenu = false
 	case "cleanmenu":
 		c.CleanMenu = true
 	case "nocleanmenu":

pkg/settings/config.go

@@ -60,7 +60,6 @@ type Configuration struct {
 	CleanAfter             bool     `json:"cleanAfter"`
 	Provides               bool     `json:"provides"`
 	PGPFetch               bool     `json:"pgpfetch"`
-	UpgradeMenu            bool     `json:"upgrademenu"`
 	CleanMenu              bool     `json:"cleanmenu"`
 	DiffMenu               bool     `json:"diffmenu"`
 	EditMenu               bool     `json:"editmenu"`
@@ -69,7 +68,6 @@ type Configuration struct {
 	BatchInstall           bool     `json:"batchinstall"`
 	SingleLineResults      bool     `json:"singlelineresults"`
 	SeparateSources        bool     `json:"separatesources"`
-	NewInstallEngine       bool     `json:"newinstallengine"`
 	Debug                  bool     `json:"debug"`
 	UseRPC                 bool     `json:"rpc"`
 	DoubleConfirm          bool     `json:"doubleconfirm"` // confirm install before and after build
@@ -229,14 +227,12 @@ func DefaultConfig(version string) *Configuration {
 		AnswerUpgrade:          "",
 		RemoveMake:             "ask",
 		Provides:               true,
-		UpgradeMenu:            true,
 		CleanMenu:              true,
 		DiffMenu:               true,
 		EditMenu:               false,
 		UseAsk:                 false,
 		CombinedUpgrade:        true,
 		SeparateSources:        true,
-		NewInstallEngine:       true,
 		Version:                version,
 		Debug:                  false,
 		UseRPC:                 true,

pkg/settings/parser/parser.go

@@ -425,8 +425,6 @@ func isArg(arg string) bool {
 	case "noprovides":
 	case "pgpfetch":
 	case "nopgpfetch":
-	case "upgrademenu":
-	case "noupgrademenu":
 	case "cleanmenu":
 	case "nocleanmenu":
 	case "diffmenu":

pkg/settings/runtime.go

@@ -29,9 +29,8 @@ type Runtime struct {
 	VCSStore     vcs.Store
 	CmdBuilder   exe.ICmdBuilder
 	HTTPClient   *http.Client
-	AURClient    *rpc.Client
 	VoteClient   *vote.Client
-	AURCache     aur.QueryClient
+	AURClient    aur.QueryClient
 	DBExecutor   db.Executor
 	Logger       *text.Logger
 }
@@ -101,9 +100,8 @@ func BuildRuntime(cfg *Configuration, cmdArgs *parser.Arguments, version string)
 		VCSStore:     vcsStore,
 		CmdBuilder:   cmdBuilder,
 		HTTPClient:   &http.Client{},
-		AURClient:    aurClient,
 		VoteClient:   voteClient,
-		AURCache:     aurCache,
+		AURClient:    aurCache,
 		DBExecutor:   nil,
 		Logger:       text.NewLogger(os.Stdout, os.Stderr, os.Stdin, cfg.Debug, "runtime"),
 	}

pkg/settings/runtime_test.go

@@ -39,9 +39,8 @@ func TestBuildRuntime(t *testing.T) {
 	assert.NotNil(t, runtime.VCSStore)
 	assert.NotNil(t, runtime.CmdBuilder)
 	assert.NotNil(t, runtime.HTTPClient)
-	assert.NotNil(t, runtime.AURClient)
 	assert.NotNil(t, runtime.VoteClient)
-	assert.NotNil(t, runtime.AURCache)
+	assert.NotNil(t, runtime.AURClient)
 	assert.Nil(t, runtime.DBExecutor)
 	assert.NotNil(t, runtime.Logger)
 }

preparer.go

@@ -38,21 +38,31 @@ type Hook struct {
 }
 
 type Preparer struct {
-	dbExecutor db.Executor
-	cmdBuilder exe.ICmdBuilder
-	cfg        *settings.Configuration
-	hooks      []Hook
+	dbExecutor      db.Executor
+	cmdBuilder      exe.ICmdBuilder
+	cfg             *settings.Configuration
+	hooks           []Hook
+	downloadSources bool
 
 	makeDeps []string
 }
 
-func NewPreparer(dbExecutor db.Executor, cmdBuilder exe.ICmdBuilder, cfg *settings.Configuration) *Preparer {
-	preper := &Preparer{
-		dbExecutor: dbExecutor,
-		cmdBuilder: cmdBuilder,
-		cfg:        cfg,
-		hooks:      []Hook{},
+func NewPreparerWithoutHooks(dbExecutor db.Executor, cmdBuilder exe.ICmdBuilder,
+	cfg *settings.Configuration, downloadSources bool,
+) *Preparer {
+	return &Preparer{
+		dbExecutor:      dbExecutor,
+		cmdBuilder:      cmdBuilder,
+		cfg:             cfg,
+		hooks:           []Hook{},
+		downloadSources: downloadSources,
 	}
+}
+
+func NewPreparer(dbExecutor db.Executor, cmdBuilder exe.ICmdBuilder,
+	cfg *settings.Configuration,
+) *Preparer {
+	preper := NewPreparerWithoutHooks(dbExecutor, cmdBuilder, cfg, true)
 
 	if cfg.CleanMenu {
 		preper.hooks = append(preper.hooks, Hook{
@@ -194,6 +204,10 @@ func (preper *Preparer) PrepareWorkspace(ctx context.Context, targets []map[stri
 		return nil, errA
 	}
 
+	if !preper.downloadSources {
+		return pkgBuildDirsByBase, nil
+	}
+
 	if err := mergePkgbuilds(ctx, preper.cmdBuilder, pkgBuildDirsByBase); err != nil {
 		return nil, err
 	}

print.go

@@ -20,8 +20,8 @@ import (
 	"github.com/Jguer/yay/v12/pkg/upgrade"
 )
 
-// PrintInfo prints package info like pacman -Si.
-func PrintInfo(config *settings.Configuration, a *aur.Pkg, extendedInfo bool) {
+// printInfo prints package info like pacman -Si.
+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...)
@@ -77,6 +77,7 @@ func localStatistics(ctx context.Context, cfg *settings.Configuration, dbExecuto
 	info := statistics(cfg, dbExecutor)
 
 	remoteNames := dbExecutor.InstalledRemotePackageNames()
+	remote := dbExecutor.InstalledRemotePackages()
 	text.Infoln(gotext.Get("Yay version v%s", yayVersion))
 	fmt.Println(text.Bold(text.Cyan("===========================================")))
 	text.Infoln(gotext.Get("Total installed packages: %s", text.Cyan(strconv.Itoa(info.Totaln))))
@@ -94,7 +95,20 @@ func localStatistics(ctx context.Context, cfg *settings.Configuration, dbExecuto
 	biggestPackages(dbExecutor)
 	fmt.Println(text.Bold(text.Cyan("===========================================")))
 
-	query.AURInfoPrint(ctx, cfg.Runtime.AURClient, remoteNames, cfg.RequestSplitN)
+	aurData, err := cfg.Runtime.AURClient.Get(ctx, &aur.Query{
+		Needles: remoteNames,
+		By:      aur.Name,
+	})
+	if err != nil {
+		return err
+	}
+
+	warnings := query.NewWarnings(cfg.Runtime.Logger.Child("print"))
+	for i := range aurData {
+		warnings.AddToWarnings(remote, &aurData[i])
+	}
+
+	warnings.Print()
 
 	return nil
 }
@@ -113,11 +127,11 @@ func printUpdateList(ctx context.Context, cfg *settings.Configuration, cmdArgs *
 	defer func() { settings.NoConfirm = oldNoConfirm }()
 
 	targets := mapset.NewThreadUnsafeSet(cmdArgs.Targets...)
-	grapher := dep.NewGrapher(dbExecutor, cfg.Runtime.AURCache, false, true,
+	grapher := dep.NewGrapher(dbExecutor, cfg.Runtime.AURClient, false, true,
 		false, false, cmdArgs.ExistsArg("needed"), logger.Child("grapher"))
 
 	upService := upgrade.NewUpgradeService(
-		grapher, cfg.Runtime.AURCache, dbExecutor, cfg.Runtime.VCSStore,
+		grapher, cfg.Runtime.AURClient, dbExecutor, cfg.Runtime.VCSStore,
 		cfg, true, logger.Child("upgrade"))
 
 	graph, errSysUp := upService.GraphUpgrades(ctx, nil,

print_test.go

@@ -272,13 +272,12 @@ func TestPrintUpdateList(t *testing.T) {
 			}
 
 			cfg := &settings.Configuration{
-				NewInstallEngine: true,
-				RemoveMake:       "no",
+				RemoveMake: "no",
 				Runtime: &settings.Runtime{
 					Logger:     NewTestLogger(),
 					CmdBuilder: cmdBuilder,
 					VCSStore:   &vcs.Mock{},
-					AURCache:   tc.mockData.aurCache,
+					AURClient:  tc.mockData.aurCache,
 				},
 			}
 

query.go

@@ -52,7 +52,7 @@ func syncInfo(ctx context.Context, cfg *settings.Configuration,
 			noDB = append(noDB, name)
 		}
 
-		info, err = cfg.Runtime.AURCache.Get(ctx, &aur.Query{
+		info, err = cfg.Runtime.AURClient.Get(ctx, &aur.Query{
 			Needles: noDB,
 			By:      aur.Name,
 		})
@@ -81,7 +81,7 @@ func syncInfo(ctx context.Context, cfg *settings.Configuration,
 
 	if len(info) != 0 {
 		for i := range info {
-			PrintInfo(cfg, &info[i], cmdArgs.ExistsDouble("i"))
+			printInfo(cfg, &info[i], cmdArgs.ExistsDouble("i"))
 		}
 	}
 

query_test.go

@@ -128,7 +128,7 @@ func TestSyncInfo(t *testing.T) {
 			cfg := &settings.Configuration{
 				Runtime: &settings.Runtime{
 					CmdBuilder: cmdBuilder,
-					AURCache:   mockAUR,
+					AURClient:  mockAUR,
 					Logger:     NewTestLogger(),
 				},
 			}
@@ -269,7 +269,7 @@ func TestSyncSearchAURDB(t *testing.T) {
 			cfg := &settings.Configuration{
 				Runtime: &settings.Runtime{
 					CmdBuilder: cmdBuilder,
-					AURCache:   mockAUR,
+					AURClient:  mockAUR,
 					QueryBuilder: query.NewSourceQueryBuilder(mockAUR, NewTestLogger(), "votes", parser.ModeAny, "name",
 						tc.bottomUp, tc.singleLine, tc.mixed),
 					Logger: NewTestLogger(),

sync.go

@@ -24,7 +24,7 @@ func syncInstall(ctx context.Context,
 	cmdArgs *parser.Arguments,
 	dbExecutor db.Executor,
 ) error {
-	aurCache := cfg.Runtime.AURCache
+	aurCache := cfg.Runtime.AURClient
 	refreshArg := cmdArgs.ExistsArg("y", "refresh")
 	noDeps := cmdArgs.ExistsArg("d", "nodeps")
 	noCheck := strings.Contains(cfg.MFlags, "--nocheck")

sync_test.go

@@ -107,13 +107,12 @@ func TestSyncUpgrade(t *testing.T) {
 	}
 
 	cfg := &settings.Configuration{
-		NewInstallEngine: true,
-		RemoveMake:       "no",
+		RemoveMake: "no",
 		Runtime: &settings.Runtime{
 			Logger:     text.NewLogger(io.Discard, os.Stderr, strings.NewReader("\n"), true, "test"),
 			CmdBuilder: cmdBuilder,
 			VCSStore:   &vcs.Mock{},
-			AURCache: &mockaur.MockAUR{
+			AURClient: &mockaur.MockAUR{
 				GetFn: func(ctx context.Context, query *aur.Query) ([]aur.Pkg, error) {
 					return []aur.Pkg{}, nil
 				},
@@ -221,13 +220,12 @@ func TestSyncUpgrade_IgnoreAll(t *testing.T) {
 	}
 
 	cfg := &settings.Configuration{
-		NewInstallEngine: true,
-		RemoveMake:       "no",
+		RemoveMake: "no",
 		Runtime: &settings.Runtime{
 			Logger:     text.NewLogger(io.Discard, os.Stderr, strings.NewReader("1\n"), true, "test"),
 			CmdBuilder: cmdBuilder,
 			VCSStore:   &vcs.Mock{},
-			AURCache: &mockaur.MockAUR{
+			AURClient: &mockaur.MockAUR{
 				GetFn: func(ctx context.Context, query *aur.Query) ([]aur.Pkg, error) {
 					return []aur.Pkg{}, nil
 				},
@@ -352,13 +350,12 @@ func TestSyncUpgrade_IgnoreOne(t *testing.T) {
 	}
 
 	cfg := &settings.Configuration{
-		NewInstallEngine: true,
-		RemoveMake:       "no",
+		RemoveMake: "no",
 		Runtime: &settings.Runtime{
 			Logger:     text.NewLogger(io.Discard, os.Stderr, strings.NewReader("1\n"), true, "test"),
 			CmdBuilder: cmdBuilder,
 			VCSStore:   &vcs.Mock{},
-			AURCache: &mockaur.MockAUR{
+			AURClient: &mockaur.MockAUR{
 				GetFn: func(ctx context.Context, query *aur.Query) ([]aur.Pkg, error) {
 					return []aur.Pkg{}, nil
 				},
@@ -516,15 +513,14 @@ pkgname = python-vosk
 	}
 
 	cfg := &settings.Configuration{
-		DoubleConfirm:    true,
-		NewInstallEngine: true,
-		RemoveMake:       "no",
-		BuildDir:         tmpDir,
+		DoubleConfirm: true,
+		RemoveMake:    "no",
+		BuildDir:      tmpDir,
 		Runtime: &settings.Runtime{
 			Logger:     text.NewLogger(io.Discard, os.Stderr, strings.NewReader("\n\n\n\n"), true, "test"),
 			CmdBuilder: cmdBuilder,
 			VCSStore:   &vcs.Mock{},
-			AURCache: &mockaur.MockAUR{
+			AURClient: &mockaur.MockAUR{
 				GetFn: func(ctx context.Context, query *aur.Query) ([]aur.Pkg, error) {
 					return []aur.Pkg{
 						{
@@ -702,14 +698,13 @@ func TestSyncUpgrade_NoCombinedUpgrade(t *testing.T) {
 			}
 
 			cfg := &settings.Configuration{
-				NewInstallEngine: true,
-				RemoveMake:       "no",
-				CombinedUpgrade:  false,
+				RemoveMake:      "no",
+				CombinedUpgrade: false,
 				Runtime: &settings.Runtime{
 					Logger:     text.NewLogger(io.Discard, os.Stderr, strings.NewReader("1\n"), true, "test"),
 					CmdBuilder: cmdBuilder,
 					VCSStore:   &vcs.Mock{},
-					AURCache: &mockaur.MockAUR{
+					AURClient: &mockaur.MockAUR{
 						GetFn: func(ctx context.Context, query *aur.Query) ([]aur.Pkg, error) {
 							return []aur.Pkg{}, nil
 						},

upgrade.go

@@ -1,276 +0,0 @@
-package main
-
-import (
-	"context"
-	"fmt"
-	"os"
-	"sort"
-	"strings"
-	"sync"
-
-	"github.com/Jguer/yay/v12/pkg/db"
-	"github.com/Jguer/yay/v12/pkg/intrange"
-	"github.com/Jguer/yay/v12/pkg/multierror"
-	"github.com/Jguer/yay/v12/pkg/query"
-	"github.com/Jguer/yay/v12/pkg/settings"
-	"github.com/Jguer/yay/v12/pkg/stringset"
-	"github.com/Jguer/yay/v12/pkg/text"
-	"github.com/Jguer/yay/v12/pkg/upgrade"
-
-	aur "github.com/Jguer/aur"
-	alpm "github.com/Jguer/go-alpm/v2"
-	"github.com/leonelquinteros/gotext"
-)
-
-func filterUpdateList(list []db.Upgrade, filter upgrade.Filter) []db.Upgrade {
-	tmp := list[:0]
-
-	for i := range list {
-		up := &list[i]
-		if filter(up) {
-			tmp = append(tmp, *up)
-		}
-	}
-
-	return tmp
-}
-
-// upList returns lists of packages to upgrade from each source.
-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) {
-	remote := dbExecutor.InstalledRemotePackages()
-	remoteNames := dbExecutor.InstalledRemotePackageNames()
-
-	var (
-		wg           sync.WaitGroup
-		develUp      upgrade.UpSlice
-		syncUpgrades map[string]db.SyncUpgrade
-		errs         multierror.MultiError
-	)
-
-	aurdata := make(map[string]*aur.Pkg)
-
-	for _, pkg := range remote {
-		if pkg.ShouldIgnore() {
-			warnings.Ignore.Set(pkg.Name())
-		}
-	}
-
-	if cfg.Mode.AtLeastRepo() {
-		text.OperationInfoln(gotext.Get("Searching databases for updates..."))
-		wg.Add(1)
-
-		go func() {
-			syncUpgrades, err = dbExecutor.SyncUpgrades(enableDowngrade)
-			errs.Add(err)
-			wg.Done()
-		}()
-	}
-
-	if cfg.Mode.AtLeastAUR() {
-		text.OperationInfoln(gotext.Get("Searching AUR for updates..."))
-
-		var _aurdata []aur.Pkg
-		_aurdata, err = query.AURInfo(ctx, cfg.Runtime.AURClient, remoteNames, warnings, cfg.RequestSplitN)
-
-		errs.Add(err)
-
-		if err == nil {
-			for i := range _aurdata {
-				pkg := &_aurdata[i]
-				aurdata[pkg.Name] = pkg
-			}
-
-			wg.Add(1)
-
-			go func() {
-				aurUp = upgrade.UpAUR(cfg.Runtime.Logger, remote, aurdata, cfg.TimeUpdate, enableDowngrade)
-
-				wg.Done()
-			}()
-
-			if cfg.Devel {
-				text.OperationInfoln(gotext.Get("Checking development packages..."))
-				wg.Add(1)
-
-				go func() {
-					develUp = upgrade.UpDevel(ctx, cfg.Runtime.Logger, remote, aurdata, cfg.Runtime.VCSStore)
-
-					cfg.Runtime.VCSStore.CleanOrphans(remote)
-					wg.Done()
-				}()
-			}
-		}
-	}
-
-	wg.Wait()
-
-	printLocalNewerThanAUR(remote, aurdata)
-
-	names := make(stringset.StringSet)
-
-	for _, up := range develUp.Up {
-		names.Set(up.Name)
-	}
-
-	for _, up := range aurUp.Up {
-		if !names.Get(up.Name) {
-			develUp.Up = append(develUp.Up, up)
-		}
-	}
-
-	aurUp = develUp
-	aurUp.Repos = []string{"aur", "devel"}
-
-	repoUp = upgrade.UpSlice{
-		Up:    make([]db.Upgrade, 0, len(syncUpgrades)),
-		Repos: dbExecutor.Repos(),
-	}
-	for _, up := range syncUpgrades {
-		dbUp := db.Upgrade{
-			Name:          up.Package.Name(),
-			RemoteVersion: up.Package.Version(),
-			Repository:    up.Package.DB().Name(),
-			Base:          up.Package.Base(),
-			LocalVersion:  up.LocalVersion,
-			Reason:        up.Reason,
-		}
-		if filter != nil && !filter(&dbUp) {
-			continue
-		}
-
-		repoUp.Up = append(repoUp.Up, dbUp)
-	}
-
-	aurUp.Up = filterUpdateList(aurUp.Up, filter)
-	repoUp.Up = filterUpdateList(repoUp.Up, filter)
-
-	return aurUp, repoUp, errs.Return()
-}
-
-func printLocalNewerThanAUR(
-	remote map[string]alpm.IPackage, aurdata map[string]*aur.Pkg,
-) {
-	for name, pkg := range remote {
-		aurPkg, ok := aurdata[name]
-		if !ok {
-			continue
-		}
-
-		left, right := query.GetVersionDiff(pkg.Version(), aurPkg.Version)
-
-		if !isDevelPackage(pkg) && db.VerCmp(pkg.Version(), aurPkg.Version) > 0 {
-			text.Warnln(gotext.Get("%s: local (%s) is newer than AUR (%s)",
-				text.Cyan(name),
-				left, right,
-			))
-		}
-	}
-}
-
-func isDevelName(name string) bool {
-	for _, suffix := range []string{"git", "svn", "hg", "bzr", "nightly", "insiders-bin"} {
-		if strings.HasSuffix(name, "-"+suffix) {
-			return true
-		}
-	}
-
-	return strings.Contains(name, "-always-")
-}
-
-func isDevelPackage(pkg alpm.IPackage) bool {
-	return isDevelName(pkg.Name()) || isDevelName(pkg.Base())
-}
-
-// upgradePkgsMenu handles updating the cache and installing updates.
-func upgradePkgsMenu(cfg *settings.Configuration, aurUp, repoUp upgrade.UpSlice) (stringset.StringSet, []string, error) {
-	ignore := make(stringset.StringSet)
-	targets := []string{}
-
-	allUpLen := len(repoUp.Up) + len(aurUp.Up)
-	if allUpLen == 0 {
-		return ignore, nil, nil
-	}
-
-	if !cfg.UpgradeMenu {
-		for _, pkg := range aurUp.Up {
-			targets = append(targets, pkg.Repository+"/"+pkg.Name)
-		}
-
-		return ignore, targets, nil
-	}
-
-	sort.Sort(repoUp)
-	sort.Sort(aurUp)
-
-	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(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, cfg.AnswerUpgrade, settings.NoConfirm)
-	if err != nil {
-		return nil, nil, err
-	}
-
-	// upgrade menu asks you which packages to NOT upgrade so in this case
-	// include and exclude are kind of swapped
-	include, exclude, otherInclude, otherExclude := intrange.ParseNumberMenu(numbers)
-
-	isInclude := len(exclude) == 0 && len(otherExclude) == 0
-
-	for i, pkg := range repoUp.Up {
-		if isInclude && otherInclude.Get(pkg.Repository) {
-			ignore.Set(pkg.Name)
-		}
-
-		if isInclude && !include.Get(len(repoUp.Up)-i+len(aurUp.Up)) {
-			targets = append(targets, pkg.Repository+"/"+pkg.Name)
-			continue
-		}
-
-		if !isInclude && (exclude.Get(len(repoUp.Up)-i+len(aurUp.Up)) || otherExclude.Get(pkg.Repository)) {
-			targets = append(targets, pkg.Repository+"/"+pkg.Name)
-			continue
-		}
-
-		ignore.Set(pkg.Name)
-	}
-
-	for i, pkg := range aurUp.Up {
-		if isInclude && otherInclude.Get(pkg.Repository) {
-			continue
-		}
-
-		if isInclude && !include.Get(len(aurUp.Up)-i) {
-			targets = append(targets, "aur/"+pkg.Name)
-		}
-
-		if !isInclude && (exclude.Get(len(aurUp.Up)-i) || otherExclude.Get(pkg.Repository)) {
-			targets = append(targets, "aur/"+pkg.Name)
-		}
-	}
-
-	return ignore, targets, err
-}
-
-// Targets for sys upgrade.
-func sysupgradeTargets(ctx context.Context, cfg *settings.Configuration, dbExecutor db.Executor,
-	enableDowngrade bool,
-) (stringset.StringSet, []string, error) {
-	warnings := query.NewWarnings(cfg.Runtime.Logger)
-
-	aurUp, repoUp, err := upList(ctx, cfg, warnings, dbExecutor, enableDowngrade,
-		func(*upgrade.Upgrade) bool { return true })
-	if err != nil {
-		return nil, nil, err
-	}
-
-	warnings.Print()
-
-	return upgradePkgsMenu(cfg, aurUp, repoUp)
-}

vcs.go

@@ -2,53 +2,53 @@ package main
 
 import (
 	"context"
-	"path/filepath"
-	"strings"
+	"os"
 	"sync"
 
+	"github.com/Jguer/aur"
 	"github.com/leonelquinteros/gotext"
 
 	"github.com/Jguer/yay/v12/pkg/db"
 	"github.com/Jguer/yay/v12/pkg/dep"
-	"github.com/Jguer/yay/v12/pkg/download"
-	"github.com/Jguer/yay/v12/pkg/query"
 	"github.com/Jguer/yay/v12/pkg/settings"
 	"github.com/Jguer/yay/v12/pkg/srcinfo"
-	"github.com/Jguer/yay/v12/pkg/stringset"
 	"github.com/Jguer/yay/v12/pkg/text"
 )
 
+func infoToInstallInfo(info []aur.Pkg) []map[string]*dep.InstallInfo {
+	installInfo := make([]map[string]*dep.InstallInfo, 1)
+	installInfo[0] = map[string]*dep.InstallInfo{}
+
+	for i := range info {
+		pkg := &info[i]
+		installInfo[0][pkg.Name] = &dep.InstallInfo{
+			AURBase: &pkg.PackageBase,
+			Source:  dep.AUR,
+		}
+	}
+
+	return installInfo
+}
+
 // createDevelDB forces yay to create a DB of the existing development packages.
 func createDevelDB(ctx context.Context, cfg *settings.Configuration, dbExecutor db.Executor) error {
 	remoteNames := dbExecutor.InstalledRemotePackageNames()
-	info, err := query.AURInfoPrint(ctx, cfg.Runtime.AURClient, remoteNames, cfg.RequestSplitN)
+
+	cfg.Runtime.QueryBuilder.Execute(ctx, dbExecutor, remoteNames)
+	info, err := cfg.Runtime.AURClient.Get(ctx, &aur.Query{
+		Needles:  remoteNames,
+		By:       aur.Name,
+		Contains: false,
+	})
 	if err != nil {
 		return err
 	}
 
-	bases := dep.GetBases(info)
-	toSkip := pkgbuildsToSkip(cfg, bases, stringset.FromSlice(remoteNames))
-
-	targets := make([]string, 0, len(bases))
-	pkgBuildDirsByBase := make(map[string]string, len(bases))
+	preper := NewPreparerWithoutHooks(dbExecutor, cfg.Runtime.CmdBuilder, cfg, false)
 
-	for _, base := range bases {
-		if !toSkip.Get(base.Pkgbase()) {
-			targets = append(targets, base.Pkgbase())
-		}
-
-		pkgBuildDirsByBase[base.Pkgbase()] = filepath.Join(cfg.BuildDir, base.Pkgbase())
-	}
-
-	toSkipSlice := toSkip.ToSlice()
-	if len(toSkipSlice) != 0 {
-		text.OperationInfoln(
-			gotext.Get("PKGBUILD up to date, Skipping (%d/%d): %s",
-				len(toSkipSlice), len(bases), text.Cyan(strings.Join(toSkipSlice, ", "))))
-	}
-
-	if _, errA := download.AURPKGBUILDRepos(ctx,
-		cfg.Runtime.CmdBuilder, targets, cfg.AURURL, cfg.BuildDir, false); errA != nil {
+	mapInfo := infoToInstallInfo(info)
+	pkgBuildDirsByBase, err := preper.Run(ctx, os.Stdout, mapInfo)
+	if err != nil {
 		return err
 	}
 

vote.go

@@ -5,11 +5,9 @@ import (
 	"errors"
 	"fmt"
 
-	"github.com/Jguer/aur/rpc"
+	"github.com/Jguer/aur"
 	"github.com/Jguer/votar/pkg/vote"
 	"github.com/leonelquinteros/gotext"
-
-	"github.com/Jguer/yay/v12/pkg/query"
 )
 
 type ErrAURVote struct {
@@ -22,10 +20,13 @@ func (e *ErrAURVote) Error() string {
 }
 
 func handlePackageVote(ctx context.Context,
-	targets []string, aurClient rpc.ClientInterface,
-	voteClient *vote.Client, splitN int, upvote bool,
+	targets []string, aurClient aur.QueryClient,
+	voteClient *vote.Client, upvote bool,
 ) error {
-	infos, err := query.AURInfoPrint(ctx, aurClient, targets, splitN)
+	infos, err := aurClient.Get(ctx, &aur.Query{
+		Needles: targets,
+		By:      aur.Name,
+	})
 	if err != nil {
 		return err
 	}