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
This commit is contained in:
41 files changed
+123
-2515
No files matched your search
+1
-1
@@ -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))
|
||||
})
|
||||
|
||||
@@ -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 {
|
||||
|
||||
@@ -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,
|
||||
|
||||
+2
-3
@@ -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,
|
||||
},
|
||||
}
|
||||
|
||||
|
||||
+2
-2
@@ -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'
|
||||
|
||||
@@ -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
|
||||
|
||||
@@ -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]"
|
||||
|
||||
@@ -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.
|
||||
|
||||
@@ -310,17 +310,6 @@ before building.
|
||||
\fBWarning\fR: Yay resolves dependencies ahead of time via the RPC. It is not
|
||||
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.
|
||||
@@ -333,10 +322,6 @@ Do not show the diff menu.
|
||||
.B \-\-noeditmenu
|
||||
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.
|
||||
|
||||
@@ -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
|
||||
@@ -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=
|
||||
|
||||
-681
@@ -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
|
||||
}
|
||||
+1
-1
@@ -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 {
|
||||
|
||||
@@ -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
|
||||
},
|
||||
|
||||
@@ -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)
|
||||
|
||||
@@ -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
|
||||
|
||||
@@ -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()
|
||||
|
||||
@@ -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
|
||||
}
|
||||
@@ -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
|
||||
}
|
||||
@@ -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("")
|
||||
}
|
||||
@@ -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))
|
||||
}
|
||||
@@ -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
|
||||
}
|
||||
@@ -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
|
||||
}
|
||||
@@ -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
|
||||
|
||||
@@ -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 {
|
||||
|
||||
@@ -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
|
||||
}
|
||||
@@ -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":
|
||||
|
||||
@@ -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":
|
||||
|
||||
@@ -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,
|
||||
|
||||
@@ -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":
|
||||
|
||||
@@ -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"),
|
||||
}
|
||||
|
||||
@@ -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)
|
||||
}
|
||||
+24
-10
@@ -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
|
||||
}
|
||||
|
||||
@@ -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,
|
||||
|
||||
+2
-3
@@ -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,
|
||||
},
|
||||
}
|
||||
|
||||
|
||||
@@ -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"))
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
+2
-2
@@ -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(),
|
||||
|
||||
@@ -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")
|
||||
|
||||
+13
-18
@@ -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
|
||||
},
|
||||
|
||||
-276
@@ -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)
|
||||
}
|
||||
@@ -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))
|
||||
preper := NewPreparerWithoutHooks(dbExecutor, cfg.Runtime.CmdBuilder, cfg, false)
|
||||
|
||||
targets := make([]string, 0, len(bases))
|
||||
pkgBuildDirsByBase := make(map[string]string, len(bases))
|
||||
|
||||
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
|
||||
}
|
||||
|
||||
|
||||
@@ -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
|
||||
}
|
||||
|
||||
Reference in new issue
Block a user