system/yay
system/yay
1
0
Fork 0
mirror of https://github.com/Jguer/yay synced 2024-07-09 04:46:19 +00:00
Code Issues Projects Releases Wiki Activity

refactor(exe): move sudo loop into CmdBuilder

Browse Source
This commit is contained in:
jguer 2021-08-08 20:22:39 +02:00 committed by J Guerreiro
parent 444151de0d
commit 5c11c01d85
21 changed files with 146 additions and 143 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

10
clean.go
View File

@ -37,7 +37,7 @@ func cleanRemove(cmdArgs *parser.Arguments, pkgNames []string) error {
_ = arguments.AddArg("R") _ = arguments.AddArg("R")
arguments.AddTarget(pkgNames...) arguments.AddTarget(pkgNames...)
return config.Runtime.CmdRunner.Show( return config.Runtime.CmdBuilder.Show(
config.Runtime.CmdBuilder.BuildPacmanCmd( config.Runtime.CmdBuilder.BuildPacmanCmd(
arguments, config.Runtime.Mode, settings.NoConfirm)) arguments, config.Runtime.Mode, settings.NoConfirm))
} }
@ -57,7 +57,7 @@ func syncClean(cmdArgs *parser.Arguments, dbExecutor db.Executor) error {
} }
if config.Runtime.Mode == parser.ModeRepo || config.Runtime.Mode == parser.ModeAny { if config.Runtime.Mode == parser.ModeRepo || config.Runtime.Mode == parser.ModeAny {
if err := config.Runtime.CmdRunner.Show(config.Runtime.CmdBuilder.BuildPacmanCmd( if err := config.Runtime.CmdBuilder.Show(config.Runtime.CmdBuilder.BuildPacmanCmd(
cmdArgs, config.Runtime.Mode, settings.NoConfirm)); err != nil { cmdArgs, config.Runtime.Mode, settings.NoConfirm)); err != nil {
return err return err
} }
@ -177,7 +177,7 @@ func cleanUntracked() error {
dir := filepath.Join(config.BuildDir, file.Name()) dir := filepath.Join(config.BuildDir, file.Name())
if isGitRepository(dir) { if isGitRepository(dir) {
if err := config.Runtime.CmdRunner.Show(config.Runtime.CmdBuilder.BuildGitCmd(dir, "clean", "-fx")); err != nil { if err := config.Runtime.CmdBuilder.Show(config.Runtime.CmdBuilder.BuildGitCmd(dir, "clean", "-fx")); err != nil {
text.Warnln(gotext.Get("Unable to clean:"), dir) text.Warnln(gotext.Get("Unable to clean:"), dir)
return err return err
} }
@ -202,12 +202,12 @@ func cleanAfter(bases []dep.Base) {
text.OperationInfoln(gotext.Get("Cleaning (%d/%d): %s", i+1, len(bases), text.Cyan(dir))) text.OperationInfoln(gotext.Get("Cleaning (%d/%d): %s", i+1, len(bases), text.Cyan(dir)))
_, stderr, err := config.Runtime.CmdRunner.Capture(config.Runtime.CmdBuilder.BuildGitCmd(dir, "reset", "--hard", "HEAD"), 0) _, stderr, err := config.Runtime.CmdBuilder.Capture(config.Runtime.CmdBuilder.BuildGitCmd(dir, "reset", "--hard", "HEAD"), 0)
if err != nil { if err != nil {
text.Errorln(gotext.Get("error resetting %s: %s", base.String(), stderr)) text.Errorln(gotext.Get("error resetting %s: %s", base.String(), stderr))
} }
if err := config.Runtime.CmdRunner.Show(config.Runtime.CmdBuilder.BuildGitCmd(dir, "clean", "-fx", "--exclude='*.pkg.*'")); err != nil { if err := config.Runtime.CmdBuilder.Show(config.Runtime.CmdBuilder.BuildGitCmd(dir, "clean", "-fx", "--exclude='*.pkg.*'")); err != nil {
fmt.Fprintln(os.Stderr, err) fmt.Fprintln(os.Stderr, err)
} }
} }

28
cmd.go
View File

@ -150,7 +150,7 @@ func handleCmd(cmdArgs *parser.Arguments, dbExecutor db.Executor) error {
} }
if config.SudoLoop && cmdArgs.NeedRoot(config.Runtime.Mode) { if config.SudoLoop && cmdArgs.NeedRoot(config.Runtime.Mode) {
sudoLoopBackground() config.Runtime.CmdBuilder.SudoLoop()
} }
switch cmdArgs.Op { switch cmdArgs.Op {
@ -158,10 +158,10 @@ func handleCmd(cmdArgs *parser.Arguments, dbExecutor db.Executor) error {
handleVersion() handleVersion()
return nil return nil
case "D", "database": case "D", "database":
return config.Runtime.CmdRunner.Show(config.Runtime.CmdBuilder.BuildPacmanCmd( return config.Runtime.CmdBuilder.Show(config.Runtime.CmdBuilder.BuildPacmanCmd(
cmdArgs, config.Runtime.Mode, settings.NoConfirm)) cmdArgs, config.Runtime.Mode, settings.NoConfirm))
case "F", "files": case "F", "files":
return config.Runtime.CmdRunner.Show(config.Runtime.CmdBuilder.BuildPacmanCmd( return config.Runtime.CmdBuilder.Show(config.Runtime.CmdBuilder.BuildPacmanCmd(
cmdArgs, config.Runtime.Mode, settings.NoConfirm)) cmdArgs, config.Runtime.Mode, settings.NoConfirm))
case "Q", "query": case "Q", "query":
return handleQuery(cmdArgs, dbExecutor) return handleQuery(cmdArgs, dbExecutor)
@ -170,10 +170,10 @@ func handleCmd(cmdArgs *parser.Arguments, dbExecutor db.Executor) error {
case "S", "sync": case "S", "sync":
return handleSync(cmdArgs, dbExecutor) return handleSync(cmdArgs, dbExecutor)
case "T", "deptest": case "T", "deptest":
return config.Runtime.CmdRunner.Show(config.Runtime.CmdBuilder.BuildPacmanCmd( return config.Runtime.CmdBuilder.Show(config.Runtime.CmdBuilder.BuildPacmanCmd(
cmdArgs, config.Runtime.Mode, settings.NoConfirm)) cmdArgs, config.Runtime.Mode, settings.NoConfirm))
case "U", "upgrade": case "U", "upgrade":
return config.Runtime.CmdRunner.Show(config.Runtime.CmdBuilder.BuildPacmanCmd( return config.Runtime.CmdBuilder.Show(config.Runtime.CmdBuilder.BuildPacmanCmd(
cmdArgs, config.Runtime.Mode, settings.NoConfirm)) cmdArgs, config.Runtime.Mode, settings.NoConfirm))
case "G", "getpkgbuild": case "G", "getpkgbuild":
return handleGetpkgbuild(cmdArgs, dbExecutor) return handleGetpkgbuild(cmdArgs, dbExecutor)
@ -216,7 +216,7 @@ func handleQuery(cmdArgs *parser.Arguments, dbExecutor db.Executor) error {
} }
return printUpdateList(cmdArgs, dbExecutor, cmdArgs.ExistsDouble("u", "sysupgrade"), filter) return printUpdateList(cmdArgs, dbExecutor, cmdArgs.ExistsDouble("u", "sysupgrade"), filter)
} }
return config.Runtime.CmdRunner.Show(config.Runtime.CmdBuilder.BuildPacmanCmd( return config.Runtime.CmdBuilder.Show(config.Runtime.CmdBuilder.BuildPacmanCmd(
cmdArgs, config.Runtime.Mode, settings.NoConfirm)) cmdArgs, config.Runtime.Mode, settings.NoConfirm))
} }
@ -225,7 +225,7 @@ func handleHelp(cmdArgs *parser.Arguments) error {
usage() usage()
return nil return nil
} }
return config.Runtime.CmdRunner.Show(config.Runtime.CmdBuilder.BuildPacmanCmd( return config.Runtime.CmdBuilder.Show(config.Runtime.CmdBuilder.BuildPacmanCmd(
cmdArgs, config.Runtime.Mode, settings.NoConfirm)) cmdArgs, config.Runtime.Mode, settings.NoConfirm))
} }
@ -304,7 +304,7 @@ func handleSync(cmdArgs *parser.Arguments, dbExecutor db.Executor) error {
return syncSearch(targets, config.Runtime.AURClient, dbExecutor) return syncSearch(targets, config.Runtime.AURClient, dbExecutor)
} }
if cmdArgs.ExistsArg("p", "print", "print-format") { if cmdArgs.ExistsArg("p", "print", "print-format") {
return config.Runtime.CmdRunner.Show(config.Runtime.CmdBuilder.BuildPacmanCmd( return config.Runtime.CmdBuilder.Show(config.Runtime.CmdBuilder.BuildPacmanCmd(
cmdArgs, config.Runtime.Mode, settings.NoConfirm)) cmdArgs, config.Runtime.Mode, settings.NoConfirm))
} }
if cmdArgs.ExistsArg("c", "clean") { if cmdArgs.ExistsArg("c", "clean") {
@ -314,7 +314,7 @@ func handleSync(cmdArgs *parser.Arguments, dbExecutor db.Executor) error {
return syncList(config.Runtime.HTTPClient, cmdArgs, dbExecutor) return syncList(config.Runtime.HTTPClient, cmdArgs, dbExecutor)
} }
if cmdArgs.ExistsArg("g", "groups") { if cmdArgs.ExistsArg("g", "groups") {
return config.Runtime.CmdRunner.Show(config.Runtime.CmdBuilder.BuildPacmanCmd( return config.Runtime.CmdBuilder.Show(config.Runtime.CmdBuilder.BuildPacmanCmd(
cmdArgs, config.Runtime.Mode, settings.NoConfirm)) cmdArgs, config.Runtime.Mode, settings.NoConfirm))
} }
if cmdArgs.ExistsArg("i", "info") { if cmdArgs.ExistsArg("i", "info") {
@ -327,14 +327,14 @@ func handleSync(cmdArgs *parser.Arguments, dbExecutor db.Executor) error {
return install(cmdArgs, dbExecutor, false) return install(cmdArgs, dbExecutor, false)
} }
if cmdArgs.ExistsArg("y", "refresh") { if cmdArgs.ExistsArg("y", "refresh") {
return config.Runtime.CmdRunner.Show(config.Runtime.CmdBuilder.BuildPacmanCmd( return config.Runtime.CmdBuilder.Show(config.Runtime.CmdBuilder.BuildPacmanCmd(
cmdArgs, config.Runtime.Mode, settings.NoConfirm)) cmdArgs, config.Runtime.Mode, settings.NoConfirm))
} }
return nil return nil
} }
func handleRemove(cmdArgs *parser.Arguments, localCache *vcs.InfoStore) error { func handleRemove(cmdArgs *parser.Arguments, localCache *vcs.InfoStore) error {
err := config.Runtime.CmdRunner.Show(config.Runtime.CmdBuilder.BuildPacmanCmd( err := config.Runtime.CmdBuilder.Show(config.Runtime.CmdBuilder.BuildPacmanCmd(
cmdArgs, config.Runtime.Mode, settings.NoConfirm)) cmdArgs, config.Runtime.Mode, settings.NoConfirm))
if err == nil { if err == nil {
localCache.RemovePackage(cmdArgs.Targets) localCache.RemovePackage(cmdArgs.Targets)
@ -450,10 +450,6 @@ func displayNumberMenu(pkgS []string, dbExecutor db.Executor, cmdArgs *parser.Ar
return nil return nil
} }
if config.SudoLoop {
sudoLoopBackground()
}
return install(arguments, dbExecutor, true) return install(arguments, dbExecutor, true)
} }
@ -499,7 +495,7 @@ func syncList(httpClient *http.Client, cmdArgs *parser.Arguments, dbExecutor db.
} }
if (config.Runtime.Mode == parser.ModeAny || config.Runtime.Mode == parser.ModeRepo) && (len(cmdArgs.Targets) != 0 || !aur) { if (config.Runtime.Mode == parser.ModeAny || config.Runtime.Mode == parser.ModeRepo) && (len(cmdArgs.Targets) != 0 || !aur) {
return config.Runtime.CmdRunner.Show(config.Runtime.CmdBuilder.BuildPacmanCmd( return config.Runtime.CmdBuilder.Show(config.Runtime.CmdBuilder.BuildPacmanCmd(
cmdArgs, config.Runtime.Mode, settings.NoConfirm)) cmdArgs, config.Runtime.Mode, settings.NoConfirm))
} }

14
diff.go
View File

@ -50,7 +50,7 @@ func showPkgbuildDiffs(bases []dep.Base, cloned map[string]bool) error {
} else { } else {
args = append(args, "--color=never") args = append(args, "--color=never")
} }
_ = config.Runtime.CmdRunner.Show(config.Runtime.CmdBuilder.BuildGitCmd(dir, args...)) _ = config.Runtime.CmdBuilder.Show(config.Runtime.CmdBuilder.BuildGitCmd(dir, args...))
} }
return errMulti.Return() return errMulti.Return()
@ -60,7 +60,7 @@ func showPkgbuildDiffs(bases []dep.Base, cloned map[string]bool) error {
// HEAD@{upstream} // HEAD@{upstream}
func gitHasDiff(path, name string) (bool, error) { func gitHasDiff(path, name string) (bool, error) {
if gitHasLastSeenRef(path, name) { if gitHasLastSeenRef(path, name) {
stdout, stderr, err := config.Runtime.CmdRunner.Capture( stdout, stderr, err := config.Runtime.CmdBuilder.Capture(
config.Runtime.CmdBuilder.BuildGitCmd(filepath.Join(path, name), "rev-parse", gitDiffRefName, "HEAD@{upstream}"), 0) config.Runtime.CmdBuilder.BuildGitCmd(filepath.Join(path, name), "rev-parse", gitDiffRefName, "HEAD@{upstream}"), 0)
if err != nil { if err != nil {
return false, fmt.Errorf("%s%s", stderr, err) return false, fmt.Errorf("%s%s", stderr, err)
@ -79,7 +79,7 @@ func gitHasDiff(path, name string) (bool, error) {
// Return wether or not we have reviewed a diff yet. It checks for the existence of // Return wether or not we have reviewed a diff yet. It checks for the existence of
// YAY_DIFF_REVIEW in the git ref-list // YAY_DIFF_REVIEW in the git ref-list
func gitHasLastSeenRef(path, name string) bool { func gitHasLastSeenRef(path, name string) bool {
_, _, err := config.Runtime.CmdRunner.Capture( _, _, err := config.Runtime.CmdBuilder.Capture(
config.Runtime.CmdBuilder.BuildGitCmd( config.Runtime.CmdBuilder.BuildGitCmd(
filepath.Join(path, name), "rev-parse", "--quiet", "--verify", gitDiffRefName), 0) filepath.Join(path, name), "rev-parse", "--quiet", "--verify", gitDiffRefName), 0)
return err == nil return err == nil
@ -89,7 +89,7 @@ func gitHasLastSeenRef(path, name string) bool {
// If it does not it will return empty tree as no diff have been reviewed yet. // If it does not it will return empty tree as no diff have been reviewed yet.
func getLastSeenHash(path, name string) (string, error) { func getLastSeenHash(path, name string) (string, error) {
if gitHasLastSeenRef(path, name) { if gitHasLastSeenRef(path, name) {
stdout, stderr, err := config.Runtime.CmdRunner.Capture( stdout, stderr, err := config.Runtime.CmdBuilder.Capture(
config.Runtime.CmdBuilder.BuildGitCmd( config.Runtime.CmdBuilder.BuildGitCmd(
filepath.Join(path, name), "rev-parse", gitDiffRefName), 0) filepath.Join(path, name), "rev-parse", gitDiffRefName), 0)
if err != nil { if err != nil {
@ -105,7 +105,7 @@ func getLastSeenHash(path, name string) (string, error) {
// Update the YAY_DIFF_REVIEW ref to HEAD. We use this ref to determine which diff were // Update the YAY_DIFF_REVIEW ref to HEAD. We use this ref to determine which diff were
// reviewed by the user // reviewed by the user
func gitUpdateSeenRef(path, name string) error { func gitUpdateSeenRef(path, name string) error {
_, stderr, err := config.Runtime.CmdRunner.Capture( _, stderr, err := config.Runtime.CmdBuilder.Capture(
config.Runtime.CmdBuilder.BuildGitCmd( config.Runtime.CmdBuilder.BuildGitCmd(
filepath.Join(path, name), "update-ref", gitDiffRefName, "HEAD"), 0) filepath.Join(path, name), "update-ref", gitDiffRefName, "HEAD"), 0)
if err != nil { if err != nil {
@ -115,14 +115,14 @@ func gitUpdateSeenRef(path, name string) error {
} }
func gitMerge(path, name string) error { func gitMerge(path, name string) error {
_, stderr, err := config.Runtime.CmdRunner.Capture( _, stderr, err := config.Runtime.CmdBuilder.Capture(
config.Runtime.CmdBuilder.BuildGitCmd( config.Runtime.CmdBuilder.BuildGitCmd(
filepath.Join(path, name), "reset", "--hard", "HEAD"), 0) filepath.Join(path, name), "reset", "--hard", "HEAD"), 0)
if err != nil { if err != nil {
return fmt.Errorf(gotext.Get("error resetting %s: %s", name, stderr)) return fmt.Errorf(gotext.Get("error resetting %s: %s", name, stderr))
} }
_, stderr, err = config.Runtime.CmdRunner.Capture( _, stderr, err = config.Runtime.CmdBuilder.Capture(
config.Runtime.CmdBuilder.BuildGitCmd( config.Runtime.CmdBuilder.BuildGitCmd(
filepath.Join(path, name), "merge", "--no-edit", "--ff"), 0) filepath.Join(path, name), "merge", "--no-edit", "--ff"), 0)
if err != nil { if err != nil {

31
exec.go
View File

@ -1,31 +0,0 @@
package main
import (
"fmt"
"os"
"os/exec"
"time"
)
func sudoLoopBackground() {
updateSudo()
go sudoLoop()
}
func sudoLoop() {
for {
updateSudo()
time.Sleep(241 * time.Second)
}
}
func updateSudo() {
for {
err := config.Runtime.CmdRunner.Show(exec.Command(config.SudoBin, "-v"))
if err != nil {
fmt.Fprintln(os.Stderr, err)
} else {
break
}
}
}

2
get.go
View File

@ -50,7 +50,7 @@ func getPkgbuilds(dbExecutor db.Executor, config *settings.Configuration, target
if err != nil { if err != nil {
return err return err
} }
cloned, errD := download.PKGBUILDRepos(dbExecutor, config.Runtime.CmdRunner, cloned, errD := download.PKGBUILDRepos(dbExecutor,
config.Runtime.CmdBuilder, targets, config.Runtime.Mode, config.AURURL, wd, force) config.Runtime.CmdBuilder, targets, config.Runtime.Mode, config.AURURL, wd, force)
if errD != nil { if errD != nil {
text.Errorln(errD) text.Errorln(errD)

30
install.go
View File

@ -38,7 +38,7 @@ func asdeps(cmdArgs *parser.Arguments, pkgs []string) (err error) {
cmdArgs = cmdArgs.CopyGlobal() cmdArgs = cmdArgs.CopyGlobal()
_ = cmdArgs.AddArg("q", "D", "asdeps") _ = cmdArgs.AddArg("q", "D", "asdeps")
cmdArgs.AddTarget(pkgs...) cmdArgs.AddTarget(pkgs...)
err = config.Runtime.CmdRunner.Show(config.Runtime.CmdBuilder.BuildPacmanCmd( err = config.Runtime.CmdBuilder.Show(config.Runtime.CmdBuilder.BuildPacmanCmd(
cmdArgs, config.Runtime.Mode, settings.NoConfirm)) cmdArgs, config.Runtime.Mode, settings.NoConfirm))
if err != nil { if err != nil {
return fmt.Errorf(gotext.Get("error updating package install reason to dependency")) return fmt.Errorf(gotext.Get("error updating package install reason to dependency"))
@ -55,7 +55,7 @@ func asexp(cmdArgs *parser.Arguments, pkgs []string) (err error) {
cmdArgs = cmdArgs.CopyGlobal() cmdArgs = cmdArgs.CopyGlobal()
_ = cmdArgs.AddArg("q", "D", "asexplicit") _ = cmdArgs.AddArg("q", "D", "asexplicit")
cmdArgs.AddTarget(pkgs...) cmdArgs.AddTarget(pkgs...)
err = config.Runtime.CmdRunner.Show(config.Runtime.CmdBuilder.BuildPacmanCmd( err = config.Runtime.CmdBuilder.Show(config.Runtime.CmdBuilder.BuildPacmanCmd(
cmdArgs, config.Runtime.Mode, settings.NoConfirm)) cmdArgs, config.Runtime.Mode, settings.NoConfirm))
if err != nil { if err != nil {
return fmt.Errorf(gotext.Get("error updating package install reason to explicit")) return fmt.Errorf(gotext.Get("error updating package install reason to explicit"))
@ -170,7 +170,7 @@ func install(cmdArgs *parser.Arguments, dbExecutor db.Executor, ignoreProviders
if arguments.ExistsArg("ignore") { if arguments.ExistsArg("ignore") {
cmdArgs.CreateOrAppendOption("ignore", arguments.GetArgs("ignore")...) cmdArgs.CreateOrAppendOption("ignore", arguments.GetArgs("ignore")...)
} }
return config.Runtime.CmdRunner.Show(config.Runtime.CmdBuilder.BuildPacmanCmd( return config.Runtime.CmdBuilder.Show(config.Runtime.CmdBuilder.BuildPacmanCmd(
cmdArgs, config.Runtime.Mode, settings.NoConfirm)) cmdArgs, config.Runtime.Mode, settings.NoConfirm))
} }
@ -253,7 +253,7 @@ func install(cmdArgs *parser.Arguments, dbExecutor db.Executor, ignoreProviders
len(toSkipSlice), len(toClone), text.Cyan(strings.Join(toSkipSlice, ", ")))) len(toSkipSlice), len(toClone), text.Cyan(strings.Join(toSkipSlice, ", "))))
} }
cloned, errA := download.AURPKGBUILDRepos(config.Runtime.CmdRunner, cloned, errA := download.AURPKGBUILDRepos(
config.Runtime.CmdBuilder, toClone, config.AURURL, config.BuildDir, false) config.Runtime.CmdBuilder, toClone, config.AURURL, config.BuildDir, false)
if errA != nil { if errA != nil {
return err return err
@ -344,7 +344,7 @@ func install(cmdArgs *parser.Arguments, dbExecutor db.Executor, ignoreProviders
} }
if len(arguments.Targets) > 0 || arguments.ExistsArg("u") { if len(arguments.Targets) > 0 || arguments.ExistsArg("u") {
if errShow := config.Runtime.CmdRunner.Show(config.Runtime.CmdBuilder.BuildPacmanCmd( if errShow := config.Runtime.CmdBuilder.Show(config.Runtime.CmdBuilder.BuildPacmanCmd(
arguments, config.Runtime.Mode, settings.NoConfirm)); errShow != nil { arguments, config.Runtime.Mode, settings.NoConfirm)); errShow != nil {
return errors.New(gotext.Get("error installing repo packages")) return errors.New(gotext.Get("error installing repo packages"))
} }
@ -404,7 +404,7 @@ func removeMake(do *dep.Order) error {
oldValue := settings.NoConfirm oldValue := settings.NoConfirm
settings.NoConfirm = true settings.NoConfirm = true
err = config.Runtime.CmdRunner.Show(config.Runtime.CmdBuilder.BuildPacmanCmd( err = config.Runtime.CmdBuilder.Show(config.Runtime.CmdBuilder.BuildPacmanCmd(
removeArguments, config.Runtime.Mode, settings.NoConfirm)) removeArguments, config.Runtime.Mode, settings.NoConfirm))
settings.NoConfirm = oldValue settings.NoConfirm = oldValue
@ -449,7 +449,7 @@ func earlyPacmanCall(cmdArgs *parser.Arguments, dbExecutor db.Executor) error {
} }
if cmdArgs.ExistsArg("y", "refresh") || cmdArgs.ExistsArg("u", "sysupgrade") || len(arguments.Targets) > 0 { if cmdArgs.ExistsArg("y", "refresh") || cmdArgs.ExistsArg("u", "sysupgrade") || len(arguments.Targets) > 0 {
if err := config.Runtime.CmdRunner.Show(config.Runtime.CmdBuilder.BuildPacmanCmd( if err := config.Runtime.CmdBuilder.Show(config.Runtime.CmdBuilder.BuildPacmanCmd(
arguments, config.Runtime.Mode, settings.NoConfirm)); err != nil { arguments, config.Runtime.Mode, settings.NoConfirm)); err != nil {
return errors.New(gotext.Get("error installing repo packages")) return errors.New(gotext.Get("error installing repo packages"))
} }
@ -466,7 +466,7 @@ func earlyRefresh(cmdArgs *parser.Arguments) error {
arguments.DelArg("i", "info") arguments.DelArg("i", "info")
arguments.DelArg("l", "list") arguments.DelArg("l", "list")
arguments.ClearTargets() arguments.ClearTargets()
return config.Runtime.CmdRunner.Show(config.Runtime.CmdBuilder.BuildPacmanCmd( return config.Runtime.CmdBuilder.Show(config.Runtime.CmdBuilder.BuildPacmanCmd(
arguments, config.Runtime.Mode, settings.NoConfirm)) arguments, config.Runtime.Mode, settings.NoConfirm))
} }
@ -521,7 +521,7 @@ nextpkg:
} }
func parsePackageList(dir string) (pkgdests map[string]string, pkgVersion string, err error) { func parsePackageList(dir string) (pkgdests map[string]string, pkgVersion string, err error) {
stdout, stderr, err := config.Runtime.CmdRunner.Capture( stdout, stderr, err := config.Runtime.CmdBuilder.Capture(
config.Runtime.CmdBuilder.BuildMakepkgCmd(dir, "--packagelist"), 0) config.Runtime.CmdBuilder.BuildMakepkgCmd(dir, "--packagelist"), 0)
if err != nil { if err != nil {
return nil, "", fmt.Errorf("%s %s", stderr, err) return nil, "", fmt.Errorf("%s %s", stderr, err)
@ -853,7 +853,7 @@ func downloadPkgbuildsSources(bases []dep.Base, incompatible stringset.StringSet
args = append(args, "--ignorearch") args = append(args, "--ignorearch")
} }
err = config.Runtime.CmdRunner.Show( err = config.Runtime.CmdBuilder.Show(
config.Runtime.CmdBuilder.BuildMakepkgCmd(dir, args...)) config.Runtime.CmdBuilder.BuildMakepkgCmd(dir, args...))
if err != nil { if err != nil {
return errors.New(gotext.Get("error downloading sources: %s", text.Cyan(base.String()))) return errors.New(gotext.Get("error downloading sources: %s", text.Cyan(base.String())))
@ -905,7 +905,7 @@ func buildInstallPkgbuilds(
return nil return nil
} }
if errShow := config.Runtime.CmdRunner.Show(config.Runtime.CmdBuilder.BuildPacmanCmd( if errShow := config.Runtime.CmdBuilder.Show(config.Runtime.CmdBuilder.BuildPacmanCmd(
arguments, config.Runtime.Mode, settings.NoConfirm)); errShow != nil { arguments, config.Runtime.Mode, settings.NoConfirm)); errShow != nil {
return errShow return errShow
} }
@ -965,7 +965,7 @@ func buildInstallPkgbuilds(
} }
// pkgver bump // pkgver bump
if err = config.Runtime.CmdRunner.Show( if err = config.Runtime.CmdBuilder.Show(
config.Runtime.CmdBuilder.BuildMakepkgCmd(dir, args...)); err != nil { config.Runtime.CmdBuilder.BuildMakepkgCmd(dir, args...)); err != nil {
return errors.New(gotext.Get("error making: %s", base.String())) return errors.New(gotext.Get("error making: %s", base.String()))
} }
@ -1003,7 +1003,7 @@ func buildInstallPkgbuilds(
} }
if installed { if installed {
err = config.Runtime.CmdRunner.Show( err = config.Runtime.CmdBuilder.Show(
config.Runtime.CmdBuilder.BuildMakepkgCmd( config.Runtime.CmdBuilder.BuildMakepkgCmd(
dir, "-c", "--nobuild", "--noextract", "--ignorearch")) dir, "-c", "--nobuild", "--noextract", "--ignorearch"))
if err != nil { if err != nil {
@ -1016,7 +1016,7 @@ func buildInstallPkgbuilds(
} }
if built { if built {
err = config.Runtime.CmdRunner.Show( err = config.Runtime.CmdBuilder.Show(
config.Runtime.CmdBuilder.BuildMakepkgCmd( config.Runtime.CmdBuilder.BuildMakepkgCmd(
dir, "-c", "--nobuild", "--noextract", "--ignorearch")) dir, "-c", "--nobuild", "--noextract", "--ignorearch"))
if err != nil { if err != nil {
@ -1031,7 +1031,7 @@ func buildInstallPkgbuilds(
args = append(args, "--ignorearch") args = append(args, "--ignorearch")
} }
if errMake := config.Runtime.CmdRunner.Show( if errMake := config.Runtime.CmdBuilder.Show(
config.Runtime.CmdBuilder.BuildMakepkgCmd( config.Runtime.CmdBuilder.BuildMakepkgCmd(
dir, args...)); errMake != nil { dir, args...)); errMake != nil {
return errors.New(gotext.Get("error making: %s", base.String())) return errors.New(gotext.Get("error making: %s", base.String()))

4
pkg/download/abs.go
View File

@ -83,12 +83,12 @@ func ABSPKGBUILD(httpClient *http.Client, dbName, pkgName string) ([]byte, error
} }
// ABSPKGBUILDRepo retrieves the PKGBUILD repository to a dest directory. // ABSPKGBUILDRepo retrieves the PKGBUILD repository to a dest directory.
func ABSPKGBUILDRepo(cmdRunner exe.Runner, cmdBuilder exe.GitCmdBuilder, dbName, pkgName, dest string, force bool) (bool, error) { func ABSPKGBUILDRepo(cmdBuilder exe.GitCmdBuilder, dbName, pkgName, dest string, force bool) (bool, error) {
pkgURL, err := getPackageRepoURL(dbName) pkgURL, err := getPackageRepoURL(dbName)
if err != nil { if err != nil {
return false, err return false, err
} }
return downloadGitRepo(cmdRunner, cmdBuilder, pkgURL, return downloadGitRepo(cmdBuilder, pkgURL,
pkgName, dest, force, "--single-branch", "-b", "packages/"+pkgName) pkgName, dest, force, "--single-branch", "-b", "packages/"+pkgName)
} }

6
pkg/download/abs_test.go
View File

@ -197,11 +197,12 @@ func TestABSPKGBUILDRepo(t *testing.T) {
test: t, test: t,
want: "/usr/local/bin/git --no-replace-objects -C /tmp/doesnt-exist clone --no-progress --single-branch -b packages/linux https://github.com/archlinux/svntogit-packages.git linux", want: "/usr/local/bin/git --no-replace-objects -C /tmp/doesnt-exist clone --no-progress --single-branch -b packages/linux https://github.com/archlinux/svntogit-packages.git linux",
parentBuilder: &exe.CmdBuilder{ parentBuilder: &exe.CmdBuilder{
Runner: cmdRunner,
GitBin: "/usr/local/bin/git", GitBin: "/usr/local/bin/git",
GitFlags: []string{"--no-replace-objects"}, GitFlags: []string{"--no-replace-objects"},
}, },
} }
newClone, err := ABSPKGBUILDRepo(cmdRunner, cmdBuilder, "core", "linux", "/tmp/doesnt-exist", false) newClone, err := ABSPKGBUILDRepo(cmdBuilder, "core", "linux", "/tmp/doesnt-exist", false)
assert.NoError(t, err) assert.NoError(t, err)
assert.Equal(t, true, newClone) assert.Equal(t, true, newClone)
} }
@ -221,11 +222,12 @@ func TestABSPKGBUILDRepoExistsPerms(t *testing.T) {
test: t, test: t,
want: fmt.Sprintf("/usr/local/bin/git --no-replace-objects -C %s/linux pull --ff-only", dir), want: fmt.Sprintf("/usr/local/bin/git --no-replace-objects -C %s/linux pull --ff-only", dir),
parentBuilder: &exe.CmdBuilder{ parentBuilder: &exe.CmdBuilder{
Runner: cmdRunner,
GitBin: "/usr/local/bin/git", GitBin: "/usr/local/bin/git",
GitFlags: []string{"--no-replace-objects"}, GitFlags: []string{"--no-replace-objects"},
}, },
} }
newClone, err := ABSPKGBUILDRepo(cmdRunner, cmdBuilder, "core", "linux", dir, false) newClone, err := ABSPKGBUILDRepo(cmdBuilder, "core", "linux", dir, false)
assert.NoError(t, err) assert.NoError(t, err)
assert.Equal(t, false, newClone) assert.Equal(t, false, newClone)
} }

7
pkg/download/aur.go
View File

@ -41,14 +41,13 @@ func AURPKGBUILD(httpClient *http.Client, pkgName string) ([]byte, error) {
} }
// AURPkgbuildRepo retrieves the PKGBUILD repository to a dest directory. // AURPkgbuildRepo retrieves the PKGBUILD repository to a dest directory.
func AURPKGBUILDRepo(cmdRunner exe.Runner, cmdBuilder exe.GitCmdBuilder, aurURL, pkgName, dest string, force bool) (bool, error) { func AURPKGBUILDRepo(cmdBuilder exe.GitCmdBuilder, aurURL, pkgName, dest string, force bool) (bool, error) {
pkgURL := fmt.Sprintf("%s/%s.git", aurURL, pkgName) pkgURL := fmt.Sprintf("%s/%s.git", aurURL, pkgName)
return downloadGitRepo(cmdRunner, cmdBuilder, pkgURL, pkgName, dest, force) return downloadGitRepo(cmdBuilder, pkgURL, pkgName, dest, force)
} }
func AURPKGBUILDRepos( func AURPKGBUILDRepos(
cmdRunner exe.Runner,
cmdBuilder exe.GitCmdBuilder, cmdBuilder exe.GitCmdBuilder,
targets []string, aurURL, dest string, force bool) (map[string]bool, error) { targets []string, aurURL, dest string, force bool) (map[string]bool, error) {
cloned := make(map[string]bool, len(targets)) cloned := make(map[string]bool, len(targets))
@ -67,7 +66,7 @@ func AURPKGBUILDRepos(
wg.Add(1) wg.Add(1)
go func(target string) { go func(target string) {
newClone, err := AURPKGBUILDRepo(cmdRunner, cmdBuilder, aurURL, target, dest, force) newClone, err := AURPKGBUILDRepo(cmdBuilder, aurURL, target, dest, force)
if err != nil { if err != nil {
errs.Add(err) errs.Add(err)

6
pkg/download/aur_test.go
View File

@ -80,11 +80,12 @@ func TestAURPKGBUILDRepo(t *testing.T) {
test: t, test: t,
want: "/usr/local/bin/git --no-replace-objects -C /tmp/doesnt-exist clone --no-progress https://aur.archlinux.org/yay-bin.git yay-bin", want: "/usr/local/bin/git --no-replace-objects -C /tmp/doesnt-exist clone --no-progress https://aur.archlinux.org/yay-bin.git yay-bin",
parentBuilder: &exe.CmdBuilder{ parentBuilder: &exe.CmdBuilder{
Runner: cmdRunner,
GitBin: "/usr/local/bin/git", GitBin: "/usr/local/bin/git",
GitFlags: []string{"--no-replace-objects"}, GitFlags: []string{"--no-replace-objects"},
}, },
} }
newCloned, err := AURPKGBUILDRepo(cmdRunner, cmdBuilder, "https://aur.archlinux.org", "yay-bin", "/tmp/doesnt-exist", false) newCloned, err := AURPKGBUILDRepo(cmdBuilder, "https://aur.archlinux.org", "yay-bin", "/tmp/doesnt-exist", false)
assert.NoError(t, err) assert.NoError(t, err)
assert.Equal(t, true, newCloned) assert.Equal(t, true, newCloned)
} }
@ -104,11 +105,12 @@ func TestAURPKGBUILDRepoExistsPerms(t *testing.T) {
test: t, test: t,
want: fmt.Sprintf("/usr/local/bin/git --no-replace-objects -C %s/yay-bin pull --ff-only", dir), want: fmt.Sprintf("/usr/local/bin/git --no-replace-objects -C %s/yay-bin pull --ff-only", dir),
parentBuilder: &exe.CmdBuilder{ parentBuilder: &exe.CmdBuilder{
Runner: cmdRunner,
GitBin: "/usr/local/bin/git", GitBin: "/usr/local/bin/git",
GitFlags: []string{"--no-replace-objects"}, GitFlags: []string{"--no-replace-objects"},
}, },
} }
cloned, err := AURPKGBUILDRepo(cmdRunner, cmdBuilder, "https://aur.archlinux.org", "yay-bin", dir, false) cloned, err := AURPKGBUILDRepo(cmdBuilder, "https://aur.archlinux.org", "yay-bin", dir, false)
assert.NoError(t, err) assert.NoError(t, err)
assert.Equal(t, false, cloned) assert.Equal(t, false, cloned)
} }

13
pkg/download/unified.go
View File

@ -22,8 +22,8 @@ type DBSearcher interface {
SatisfierFromDB(string, string) db.IPackage SatisfierFromDB(string, string) db.IPackage
} }
func downloadGitRepo(cmdRunner exe.Runner, func downloadGitRepo(cmdBuilder exe.GitCmdBuilder,
cmdBuilder exe.GitCmdBuilder, pkgURL, pkgName, dest string, force bool, gitArgs ...string) (bool, error) { pkgURL, pkgName, dest string, force bool, gitArgs ...string) (bool, error) {
finalDir := filepath.Join(dest, pkgName) finalDir := filepath.Join(dest, pkgName)
newClone := true newClone := true
@ -41,7 +41,7 @@ func downloadGitRepo(cmdRunner exe.Runner,
cloneArgs = append(cloneArgs, gitArgs...) cloneArgs = append(cloneArgs, gitArgs...)
cmd := cmdBuilder.BuildGitCmd(dest, cloneArgs...) cmd := cmdBuilder.BuildGitCmd(dest, cloneArgs...)
_, stderr, errCapture := cmdRunner.Capture(cmd, 0) _, stderr, errCapture := cmdBuilder.Capture(cmd, 0)
if errCapture != nil { if errCapture != nil {
return false, ErrGetPKGBUILDRepo{inner: errCapture, pkgName: pkgName, errOut: stderr} return false, ErrGetPKGBUILDRepo{inner: errCapture, pkgName: pkgName, errOut: stderr}
} }
@ -54,7 +54,7 @@ func downloadGitRepo(cmdRunner exe.Runner,
} else { } else {
cmd := cmdBuilder.BuildGitCmd(filepath.Join(dest, pkgName), "pull", "--ff-only") cmd := cmdBuilder.BuildGitCmd(filepath.Join(dest, pkgName), "pull", "--ff-only")
_, stderr, errCmd := cmdRunner.Capture(cmd, 0) _, stderr, errCmd := cmdBuilder.Capture(cmd, 0)
if errCmd != nil { if errCmd != nil {
return false, ErrGetPKGBUILDRepo{inner: errCmd, pkgName: pkgName, errOut: stderr} return false, ErrGetPKGBUILDRepo{inner: errCmd, pkgName: pkgName, errOut: stderr}
} }
@ -126,7 +126,6 @@ func PKGBUILDs(dbExecutor DBSearcher, httpClient *http.Client, targets []string,
} }
func PKGBUILDRepos(dbExecutor DBSearcher, func PKGBUILDRepos(dbExecutor DBSearcher,
cmdRunner exe.Runner,
cmdBuilder exe.GitCmdBuilder, cmdBuilder exe.GitCmdBuilder,
targets []string, mode parser.TargetMode, aurURL, dest string, force bool) (map[string]bool, error) { targets []string, mode parser.TargetMode, aurURL, dest string, force bool) (map[string]bool, error) {
cloned := make(map[string]bool, len(targets)) cloned := make(map[string]bool, len(targets))
@ -155,9 +154,9 @@ func PKGBUILDRepos(dbExecutor DBSearcher,
var newClone bool var newClone bool
if aur { if aur {
newClone, err = AURPKGBUILDRepo(cmdRunner, cmdBuilder, aurURL, pkgName, dest, force) newClone, err = AURPKGBUILDRepo(cmdBuilder, aurURL, pkgName, dest, force)
} else { } else {
newClone, err = ABSPKGBUILDRepo(cmdRunner, cmdBuilder, dbName, pkgName, dest, force) newClone, err = ABSPKGBUILDRepo(cmdBuilder, dbName, pkgName, dest, force)
} }
if err != nil { if err != nil {

11
pkg/download/utils_test.go
View File

@ -9,8 +9,7 @@ import (
"github.com/Jguer/yay/v10/pkg/settings/exe" "github.com/Jguer/yay/v10/pkg/settings/exe"
) )
type testRunner struct { type testRunner struct{}
}
func (t *testRunner) Capture(cmd *exec.Cmd, timeout int64) (stdout string, stderr string, err error) { func (t *testRunner) Capture(cmd *exec.Cmd, timeout int64) (stdout string, stderr string, err error) {
return "", "", nil return "", "", nil
@ -35,3 +34,11 @@ func (t *testGitBuilder) BuildGitCmd(dir string, extraArgs ...string) *exec.Cmd
t.index += 1 t.index += 1
return cmd return cmd
} }
func (c *testGitBuilder) Show(cmd *exec.Cmd) error {
return c.parentBuilder.Show(cmd)
}
func (c *testGitBuilder) Capture(cmd *exec.Cmd, timeout int64) (stdout, stderr string, err error) {
return c.parentBuilder.Capture(cmd, timeout)
}

2
pkg/settings/args.go
View File

@ -15,7 +15,7 @@ func (c *Configuration) ParseCommandLine(a *parser.Arguments) error {
c.extractYayOptions(a) c.extractYayOptions(a)
// Reload CmdBuilder // Reload CmdBuilder
c.Runtime.CmdBuilder = c.CmdBuilder() c.Runtime.CmdBuilder = c.CmdBuilder(nil)
return nil return nil
} }

15
pkg/settings/config.go
View File

@ -208,8 +208,7 @@ func NewConfig(version string) (*Configuration, error) {
Mode: parser.ModeAny, Mode: parser.ModeAny,
SaveConfig: false, SaveConfig: false,
CompletionPath: filepath.Join(cacheHome, completionFileName), CompletionPath: filepath.Join(cacheHome, completionFileName),
CmdRunner: &exe.OSRunner{}, CmdBuilder: newConfig.CmdBuilder(nil),
CmdBuilder: newConfig.CmdBuilder(),
PacmanConf: nil, PacmanConf: nil,
VCSStore: nil, VCSStore: nil,
HTTPClient: &http.Client{}, HTTPClient: &http.Client{},
@ -229,8 +228,8 @@ func NewConfig(version string) (*Configuration, error) {
return nil, errAUR return nil, errAUR
} }
newConfig.Runtime.VCSStore = vcs.NewInfoStore(filepath.Join(cacheHome, vcsFileName), newConfig.Runtime.VCSStore = vcs.NewInfoStore(
newConfig.Runtime.CmdRunner, newConfig.Runtime.CmdBuilder) filepath.Join(cacheHome, vcsFileName), newConfig.Runtime.CmdBuilder)
if err := initDir(newConfig.BuildDir); err != nil { if err := initDir(newConfig.BuildDir); err != nil {
return nil, err return nil, err
@ -259,7 +258,10 @@ func (c *Configuration) load(configPath string) {
} }
} }
func (c *Configuration) CmdBuilder() exe.ICmdBuilder { func (c *Configuration) CmdBuilder(runner exe.Runner) exe.ICmdBuilder {
if runner == nil {
runner = &exe.OSRunner{}
}
return &exe.CmdBuilder{ return &exe.CmdBuilder{
GitBin: c.GitBin, GitBin: c.GitBin,
GitFlags: strings.Fields(c.GitFlags), GitFlags: strings.Fields(c.GitFlags),
@ -268,7 +270,10 @@ func (c *Configuration) CmdBuilder() exe.ICmdBuilder {
MakepkgBin: c.MakepkgBin, MakepkgBin: c.MakepkgBin,
SudoBin: c.SudoBin, SudoBin: c.SudoBin,
SudoFlags: strings.Fields(c.SudoFlags), SudoFlags: strings.Fields(c.SudoFlags),
SudoLoopEnabled: false,
PacmanBin: c.PacmanBin, PacmanBin: c.PacmanBin,
PacmanConfigPath: c.PacmanConf, PacmanConfigPath: c.PacmanConf,
PacmanDBPath: "",
Runner: runner,
} }
} }

38
pkg/settings/exe/cmd_builder.go
View File

@ -13,16 +13,21 @@ import (
"github.com/Jguer/yay/v10/pkg/text" "github.com/Jguer/yay/v10/pkg/text"
) )
const SudoLoopDuration = 241
type GitCmdBuilder interface { type GitCmdBuilder interface {
Runner
BuildGitCmd(dir string, extraArgs ...string) *exec.Cmd BuildGitCmd(dir string, extraArgs ...string) *exec.Cmd
} }
type ICmdBuilder interface { type ICmdBuilder interface {
Runner
BuildGitCmd(dir string, extraArgs ...string) *exec.Cmd BuildGitCmd(dir string, extraArgs ...string) *exec.Cmd
BuildMakepkgCmd(dir string, extraArgs ...string) *exec.Cmd BuildMakepkgCmd(dir string, extraArgs ...string) *exec.Cmd
BuildPacmanCmd(args *parser.Arguments, mode parser.TargetMode, noConfirm bool) *exec.Cmd BuildPacmanCmd(args *parser.Arguments, mode parser.TargetMode, noConfirm bool) *exec.Cmd
AddMakepkgFlag(string) AddMakepkgFlag(string)
SetPacmanDBPath(string) SetPacmanDBPath(string)
SudoLoop()
} }
type CmdBuilder struct { type CmdBuilder struct {
@ -33,9 +38,11 @@ type CmdBuilder struct {
MakepkgBin string MakepkgBin string
SudoBin string SudoBin string
SudoFlags []string SudoFlags []string
SudoLoopEnabled bool
PacmanBin string PacmanBin string
PacmanConfigPath string PacmanConfigPath string
PacmanDBPath string PacmanDBPath string
Runner Runner
} }
func (c *CmdBuilder) BuildGitCmd(dir string, extraArgs ...string) *exec.Cmd { func (c *CmdBuilder) BuildGitCmd(dir string, extraArgs ...string) *exec.Cmd {
@ -123,3 +130,34 @@ func waitLock(dbPath string) {
} }
} }
} }
func (c *CmdBuilder) SudoLoop() {
c.updateSudo()
go c.sudoLoopBackground()
}
func (c *CmdBuilder) sudoLoopBackground() {
for {
c.updateSudo()
time.Sleep(SudoLoopDuration * time.Second)
}
}
func (c *CmdBuilder) updateSudo() {
for {
err := c.Show(exec.Command(c.SudoBin, "-v"))
if err != nil {
fmt.Fprintln(os.Stderr, err)
} else {
break
}
}
}
func (c *CmdBuilder) Show(cmd *exec.Cmd) error {
return c.Runner.Show(cmd)
}
func (c *CmdBuilder) Capture(cmd *exec.Cmd, timeout int64) (stdout, stderr string, err error) {
return c.Runner.Capture(cmd, timeout)
}

1
pkg/settings/runtime.go
View File

@ -20,7 +20,6 @@ type Runtime struct {
PacmanConf *pacmanconf.Config PacmanConf *pacmanconf.Config
VCSStore *vcs.InfoStore VCSStore *vcs.InfoStore
CmdBuilder exe.ICmdBuilder CmdBuilder exe.ICmdBuilder
CmdRunner exe.Runner
HTTPClient *http.Client HTTPClient *http.Client
AURClient *aur.Client AURClient *aur.Client
} }

11
pkg/upgrade/sources_test.go
View File

@ -17,6 +17,7 @@ import (
"github.com/Jguer/yay/v10/pkg/db/mock" "github.com/Jguer/yay/v10/pkg/db/mock"
"github.com/Jguer/yay/v10/pkg/settings" "github.com/Jguer/yay/v10/pkg/settings"
"github.com/Jguer/yay/v10/pkg/settings/exe"
"github.com/Jguer/yay/v10/pkg/vcs" "github.com/Jguer/yay/v10/pkg/vcs"
) )
@ -109,7 +110,7 @@ func Test_upDevel(t *testing.T) {
config, err := settings.NewConfig("v0") config, err := settings.NewConfig("v0")
assert.NoError(t, err) assert.NoError(t, err)
config.Runtime.CmdRunner = &MockRunner{ config.Runtime.CmdBuilder = config.CmdBuilder(&MockRunner{
Returned: []string{ Returned: []string{
"7f4c277ce7149665d1c79b76ca8fbb832a65a03b HEAD", "7f4c277ce7149665d1c79b76ca8fbb832a65a03b HEAD",
"7f4c277ce7149665d1c79b76ca8fbb832a65a03b HEAD", "7f4c277ce7149665d1c79b76ca8fbb832a65a03b HEAD",
@ -117,7 +118,7 @@ func Test_upDevel(t *testing.T) {
"cccccccccccccccccccccccccccccccccccccccc HEAD", "cccccccccccccccccccccccccccccccccccccccc HEAD",
"991c5b4146fd27f4aacf4e3111258a848934aaa1 HEAD", "991c5b4146fd27f4aacf4e3111258a848934aaa1 HEAD",
}, },
} })
type args struct { type args struct {
remote []alpm.IPackage remote []alpm.IPackage
@ -134,7 +135,6 @@ func Test_upDevel(t *testing.T) {
name: "No Updates", name: "No Updates",
args: args{ args: args{
cached: vcs.InfoStore{ cached: vcs.InfoStore{
Runner: config.Runtime.CmdRunner,
CmdBuilder: config.Runtime.CmdBuilder, CmdBuilder: config.Runtime.CmdBuilder,
}, },
remote: []alpm.IPackage{ remote: []alpm.IPackage{
@ -154,7 +154,6 @@ func Test_upDevel(t *testing.T) {
finalLen: 3, finalLen: 3,
args: args{ args: args{
cached: vcs.InfoStore{ cached: vcs.InfoStore{
Runner: config.Runtime.CmdRunner,
CmdBuilder: config.Runtime.CmdBuilder, CmdBuilder: config.Runtime.CmdBuilder,
OriginsByPackage: map[string]vcs.OriginInfoByURL{ OriginsByPackage: map[string]vcs.OriginInfoByURL{
"hello": { "hello": {
@ -225,7 +224,6 @@ func Test_upDevel(t *testing.T) {
finalLen: 1, finalLen: 1,
args: args{ args: args{
cached: vcs.InfoStore{ cached: vcs.InfoStore{
Runner: config.Runtime.CmdRunner,
CmdBuilder: config.Runtime.CmdBuilder, CmdBuilder: config.Runtime.CmdBuilder,
OriginsByPackage: map[string]vcs.OriginInfoByURL{ OriginsByPackage: map[string]vcs.OriginInfoByURL{
"hello": { "hello": {
@ -247,7 +245,6 @@ func Test_upDevel(t *testing.T) {
finalLen: 1, finalLen: 1,
args: args{ args: args{
cached: vcs.InfoStore{ cached: vcs.InfoStore{
Runner: config.Runtime.CmdRunner,
CmdBuilder: config.Runtime.CmdBuilder, CmdBuilder: config.Runtime.CmdBuilder,
OriginsByPackage: map[string]vcs.OriginInfoByURL{ OriginsByPackage: map[string]vcs.OriginInfoByURL{
"hello": { "hello": {
@ -267,7 +264,7 @@ func Test_upDevel(t *testing.T) {
} }
for _, tt := range tests { for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) { t.Run(tt.name, func(t *testing.T) {
config.Runtime.CmdRunner.(*MockRunner).t = t config.Runtime.CmdBuilder.(*exe.CmdBuilder).Runner.(*MockRunner).t = t
got := UpDevel(tt.args.remote, tt.args.aurdata, &tt.args.cached) got := UpDevel(tt.args.remote, tt.args.aurdata, &tt.args.cached)
assert.ElementsMatch(t, tt.want.Up, got.Up) assert.ElementsMatch(t, tt.want.Up, got.Up)
assert.Equal(t, tt.finalLen, len(tt.args.cached.OriginsByPackage)) assert.Equal(t, tt.finalLen, len(tt.args.cached.OriginsByPackage))

6
pkg/vcs/vcs.go
View File

@ -20,7 +20,6 @@ import (
type InfoStore struct { type InfoStore struct {
OriginsByPackage map[string]OriginInfoByURL OriginsByPackage map[string]OriginInfoByURL
FilePath string FilePath string
Runner exe.Runner
CmdBuilder exe.GitCmdBuilder CmdBuilder exe.GitCmdBuilder
} }
@ -42,12 +41,11 @@ type OriginInfo struct {
SHA string `json:"sha"` SHA string `json:"sha"`
} }
func NewInfoStore(filePath string, runner exe.Runner, cmdBuilder exe.GitCmdBuilder) *InfoStore { func NewInfoStore(filePath string, cmdBuilder exe.GitCmdBuilder) *InfoStore {
infoStore := &InfoStore{ infoStore := &InfoStore{
CmdBuilder: cmdBuilder, CmdBuilder: cmdBuilder,
FilePath: filePath, FilePath: filePath,
OriginsByPackage: map[string]OriginInfoByURL{}, OriginsByPackage: map[string]OriginInfoByURL{},
Runner: runner,
} }
return infoStore return infoStore
@ -59,7 +57,7 @@ func (v *InfoStore) getCommit(url, branch string, protocols []string) string {
protocol := protocols[len(protocols)-1] protocol := protocols[len(protocols)-1]
cmd := v.CmdBuilder.BuildGitCmd("", "ls-remote", protocol+"://"+url, branch) cmd := v.CmdBuilder.BuildGitCmd("", "ls-remote", protocol+"://"+url, branch)
stdout, _, err := v.Runner.Capture(cmd, 5) stdout, _, err := v.CmdBuilder.Capture(cmd, 5)
if err != nil { if err != nil {
if exiterr, ok := err.(*exec.ExitError); ok && exiterr.ExitCode() == 128 { if exiterr, ok := err.(*exec.ExitError); ok && exiterr.ExitCode() == 128 {
text.Warnln(gotext.Get("devel check for package failed: '%s' encountered an error", cmd.String())) text.Warnln(gotext.Get("devel check for package failed: '%s' encountered an error", cmd.String()))

50
pkg/vcs/vcs_test.go
View File

@ -55,7 +55,6 @@ func TestParsing(t *testing.T) {
func TestNewInfoStore(t *testing.T) { func TestNewInfoStore(t *testing.T) {
type args struct { type args struct {
filePath string filePath string
runner exe.Runner
cmdBuilder *exe.CmdBuilder cmdBuilder *exe.CmdBuilder
} }
tests := []struct { tests := []struct {
@ -66,18 +65,16 @@ func TestNewInfoStore(t *testing.T) {
name: "normal", name: "normal",
args: args{ args: args{
"/tmp/a.json", "/tmp/a.json",
&exe.OSRunner{}, &exe.CmdBuilder{GitBin: "git", GitFlags: []string{"--a", "--b"}, Runner: &exe.OSRunner{}},
&exe.CmdBuilder{GitBin: "git", GitFlags: []string{"--a", "--b"}},
}, },
}, },
} }
for _, tt := range tests { for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) { t.Run(tt.name, func(t *testing.T) {
got := NewInfoStore(tt.args.filePath, tt.args.runner, tt.args.cmdBuilder) got := NewInfoStore(tt.args.filePath, tt.args.cmdBuilder)
assert.NotNil(t, got) assert.NotNil(t, got)
assert.Equal(t, []string{"--a", "--b"}, got.CmdBuilder.(*exe.CmdBuilder).GitFlags) assert.Equal(t, []string{"--a", "--b"}, got.CmdBuilder.(*exe.CmdBuilder).GitFlags)
assert.Equal(t, tt.args.cmdBuilder, got.CmdBuilder) assert.Equal(t, tt.args.cmdBuilder, got.CmdBuilder)
assert.Equal(t, tt.args.runner, got.Runner)
assert.Equal(t, "/tmp/a.json", got.FilePath) assert.Equal(t, "/tmp/a.json", got.FilePath)
}) })
} }
@ -102,7 +99,6 @@ func (r *MockRunner) Capture(cmd *exec.Cmd, timeout int64) (stdout, stderr strin
func TestInfoStore_NeedsUpdate(t *testing.T) { func TestInfoStore_NeedsUpdate(t *testing.T) {
type fields struct { type fields struct {
Runner exe.Runner
CmdBuilder *exe.CmdBuilder CmdBuilder *exe.CmdBuilder
} }
type args struct { type args struct {
@ -123,10 +119,9 @@ func TestInfoStore_NeedsUpdate(t *testing.T) {
SHA: "991c5b4146fd27f4aacf4e3111258a848934aaa1", SHA: "991c5b4146fd27f4aacf4e3111258a848934aaa1",
}, },
}}, fields: fields{ }}, fields: fields{
Runner: &MockRunner{ CmdBuilder: &exe.CmdBuilder{GitBin: "git", GitFlags: []string{""}, Runner: &MockRunner{
Returned: []string{"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa HEAD"}, Returned: []string{"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa HEAD"},
}, }},
CmdBuilder: &exe.CmdBuilder{GitBin: "git", GitFlags: []string{""}},
}, },
want: true, want: true,
}, },
@ -144,13 +139,12 @@ func TestInfoStore_NeedsUpdate(t *testing.T) {
SHA: "991c5b4146fd27f4aacf4e3111258a848934aaa1", SHA: "991c5b4146fd27f4aacf4e3111258a848934aaa1",
}, },
}}, fields: fields{ }}, fields: fields{
Runner: &MockRunner{ CmdBuilder: &exe.CmdBuilder{GitBin: "git", GitFlags: []string{""}, Runner: &MockRunner{
Returned: []string{ Returned: []string{
"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa HEAD", "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa HEAD",
"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa HEAD", "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa HEAD",
}, },
}, }},
CmdBuilder: &exe.CmdBuilder{GitBin: "git", GitFlags: []string{""}},
}, },
want: true, want: true,
}, },
@ -163,10 +157,9 @@ func TestInfoStore_NeedsUpdate(t *testing.T) {
SHA: "991c5b4146fd27f4aacf4e3111258a848934aaa1", SHA: "991c5b4146fd27f4aacf4e3111258a848934aaa1",
}, },
}}, fields: fields{ }}, fields: fields{
Runner: &MockRunner{ CmdBuilder: &exe.CmdBuilder{GitBin: "git", GitFlags: []string{""}, Runner: &MockRunner{
Returned: []string{"991c5b4146fd27f4aacf4e3111258a848934aaa1 HEAD"}, Returned: []string{"991c5b4146fd27f4aacf4e3111258a848934aaa1 HEAD"},
}, }},
CmdBuilder: &exe.CmdBuilder{GitBin: "git", GitFlags: []string{""}},
}, },
want: false, want: false,
}, },
@ -179,10 +172,9 @@ func TestInfoStore_NeedsUpdate(t *testing.T) {
SHA: "991c5b4146fd27f4aacf4e3111258a848934aaa1", SHA: "991c5b4146fd27f4aacf4e3111258a848934aaa1",
}, },
}}, fields: fields{ }}, fields: fields{
Runner: &MockRunner{ CmdBuilder: &exe.CmdBuilder{GitBin: "git", GitFlags: []string{""}, Runner: &MockRunner{
Returned: []string{"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"}, Returned: []string{"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"},
}, }},
CmdBuilder: &exe.CmdBuilder{GitBin: "git", GitFlags: []string{""}},
}, },
want: false, want: false,
}, },
@ -195,10 +187,12 @@ func TestInfoStore_NeedsUpdate(t *testing.T) {
SHA: "991c5b4146fd27f4aacf4e3111258a848934aaa1", SHA: "991c5b4146fd27f4aacf4e3111258a848934aaa1",
}, },
}}, fields: fields{ }}, fields: fields{
Runner: &MockRunner{ CmdBuilder: &exe.CmdBuilder{
Returned: []string{"error"}, GitBin: "git", GitFlags: []string{""},
Runner: &MockRunner{
Returned: []string{"error"},
},
}, },
CmdBuilder: &exe.CmdBuilder{GitBin: "git", GitFlags: []string{""}},
}, },
want: false, want: false,
}, },
@ -211,10 +205,9 @@ func TestInfoStore_NeedsUpdate(t *testing.T) {
SHA: "991c5b4146fd27f4aacf4e3111258a848934aaa1", SHA: "991c5b4146fd27f4aacf4e3111258a848934aaa1",
}, },
}}, fields: fields{ }}, fields: fields{
Runner: &MockRunner{ CmdBuilder: &exe.CmdBuilder{GitBin: "git", GitFlags: []string{""}, Runner: &MockRunner{
Returned: []string{"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"}, Returned: []string{"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"},
}, }},
CmdBuilder: &exe.CmdBuilder{GitBin: "git", GitFlags: []string{""}},
}, },
want: false, want: false,
}, },
@ -222,7 +215,6 @@ func TestInfoStore_NeedsUpdate(t *testing.T) {
for _, tt := range tests { for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) { t.Run(tt.name, func(t *testing.T) {
v := &InfoStore{ v := &InfoStore{
Runner: tt.fields.Runner,
CmdBuilder: tt.fields.CmdBuilder, CmdBuilder: tt.fields.CmdBuilder,
} }
got := v.NeedsUpdate(tt.args.infos) got := v.NeedsUpdate(tt.args.infos)
@ -234,7 +226,6 @@ func TestInfoStore_NeedsUpdate(t *testing.T) {
func TestInfoStore_Update(t *testing.T) { func TestInfoStore_Update(t *testing.T) {
type fields struct { type fields struct {
OriginsByPackage map[string]OriginInfoByURL OriginsByPackage map[string]OriginInfoByURL
Runner exe.Runner
CmdBuilder *exe.CmdBuilder CmdBuilder *exe.CmdBuilder
} }
type args struct { type args struct {
@ -254,8 +245,10 @@ func TestInfoStore_Update(t *testing.T) {
}, },
fields: fields{ fields: fields{
OriginsByPackage: make(map[string]OriginInfoByURL), OriginsByPackage: make(map[string]OriginInfoByURL),
CmdBuilder: &exe.CmdBuilder{GitBin: "git", GitFlags: []string{""}}, CmdBuilder: &exe.CmdBuilder{
Runner: &MockRunner{Returned: []string{"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa HEAD"}}, GitBin: "git", GitFlags: []string{""},
Runner: &MockRunner{Returned: []string{"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa HEAD"}},
},
}, },
}, },
} }
@ -269,7 +262,6 @@ func TestInfoStore_Update(t *testing.T) {
v := &InfoStore{ v := &InfoStore{
OriginsByPackage: tt.fields.OriginsByPackage, OriginsByPackage: tt.fields.OriginsByPackage,
FilePath: file.Name(), FilePath: file.Name(),
Runner: tt.fields.Runner,
CmdBuilder: tt.fields.CmdBuilder, CmdBuilder: tt.fields.CmdBuilder,
} }
var mux sync.Mutex var mux sync.Mutex

2
query.go
View File

@ -217,7 +217,7 @@ func syncInfo(cmdArgs *parser.Arguments, pkgS []string, dbExecutor db.Executor)
arguments := cmdArgs.Copy() arguments := cmdArgs.Copy()
arguments.ClearTargets() arguments.ClearTargets()
arguments.AddTarget(repoS...) arguments.AddTarget(repoS...)
err = config.Runtime.CmdRunner.Show(config.Runtime.CmdBuilder.BuildPacmanCmd( err = config.Runtime.CmdBuilder.Show(config.Runtime.CmdBuilder.BuildPacmanCmd(
cmdArgs, config.Runtime.Mode, settings.NoConfirm)) cmdArgs, config.Runtime.Mode, settings.NoConfirm))
if err != nil { if err != nil {

2
vcs.go
View File

@ -47,7 +47,7 @@ func createDevelDB(config *settings.Configuration, dbExecutor db.Executor) error
len(toSkipSlice), len(bases), text.Cyan(strings.Join(toSkipSlice, ", ")))) len(toSkipSlice), len(bases), text.Cyan(strings.Join(toSkipSlice, ", "))))
} }
if _, errA := download.AURPKGBUILDRepos(config.Runtime.CmdRunner, if _, errA := download.AURPKGBUILDRepos(
config.Runtime.CmdBuilder, targets, config.AURURL, config.BuildDir, false); errA != nil { config.Runtime.CmdBuilder, targets, config.AURURL, config.BuildDir, false); errA != nil {
return err return err
} }