feat(deps): don't install check deps if --nocheck is passed.

feat(makepkg): automatically pass -d to makepkg if -dd is passed

install.go

@@ -67,10 +67,15 @@ func install(cmdArgs *settings.Arguments, dbExecutor db.Executor, ignoreProvider
 
 	var srcinfos map[string]*gosrc.Srcinfo
 	noDeps := cmdArgs.ExistsDouble("d", "nodeps")
+	noCheck := strings.Contains(config.MFlags, "--nocheck")
 	sysupgradeArg := cmdArgs.ExistsArg("u", "sysupgrade")
 	refreshArg := cmdArgs.ExistsArg("y", "refresh")
 	warnings := query.NewWarnings()
 
+	if noDeps {
+		config.Runtime.CmdBuilder.MakepkgFlags = append(config.Runtime.CmdBuilder.MakepkgFlags, "-d")
+	}
+
 	if config.Runtime.Mode == settings.ModeAny || config.Runtime.Mode == settings.ModeRepo {
 		if config.CombinedUpgrade {
 			if refreshArg {
@@ -136,12 +141,12 @@ func install(cmdArgs *settings.Arguments, dbExecutor db.Executor, ignoreProvider
 
 	dp, err := dep.GetPool(requestTargets,
 		warnings, dbExecutor, config.Runtime.Mode,
-		ignoreProviders, settings.NoConfirm, config.Provides, config.ReBuild, config.RequestSplitN, noDeps)
+		ignoreProviders, settings.NoConfirm, config.Provides, config.ReBuild, config.RequestSplitN, noDeps, noCheck)
 	if err != nil {
 		return err
 	}
 
-	err = dp.CheckMissing(noDeps)
+	err = dp.CheckMissing(noDeps, noCheck)
 	if err != nil {
 		return err
 	}
@@ -171,7 +176,7 @@ func install(cmdArgs *settings.Arguments, dbExecutor db.Executor, ignoreProvider
 		return err
 	}
 
-	do = dep.GetOrder(dp)
+	do = dep.GetOrder(dp, noDeps, noCheck)
 	if err != nil {
 		return err
 	}
@@ -354,7 +359,7 @@ func install(cmdArgs *settings.Arguments, dbExecutor db.Executor, ignoreProvider
 		return err
 	}
 
-	err = buildInstallPkgbuilds(cmdArgs, dbExecutor, dp, do, srcinfos, incompatible, conflicts)
+	err = buildInstallPkgbuilds(cmdArgs, dbExecutor, dp, do, srcinfos, incompatible, conflicts, noDeps, noCheck)
 	if err != nil {
 		return err
 	}
@@ -919,7 +924,7 @@ func buildInstallPkgbuilds(
 	do *dep.Order,
 	srcinfos map[string]*gosrc.Srcinfo,
 	incompatible stringset.StringSet,
-	conflicts stringset.MapStringSet,
+	conflicts stringset.MapStringSet, noDeps, noCheck bool,
 ) error {
 	arguments := cmdArgs.Copy()
 	arguments.ClearTargets()
@@ -986,7 +991,7 @@ func buildInstallPkgbuilds(
 		satisfied := true
 	all:
 		for _, pkg := range base {
-			for _, deps := range [3][]string{pkg.Depends, pkg.MakeDepends, pkg.CheckDepends} {
+			for _, deps := range dep.ComputeCombinedDepList(pkg, noDeps, noCheck) {
 				for _, dep := range deps {
 					if !dp.AlpmExecutor.LocalSatisfierExists(dep) {
 						satisfied = false

pkg/dep/depCheck.go

@@ -200,7 +200,7 @@ type missing struct {
 	Missing map[string][][]string
 }
 
-func (dp *Pool) _checkMissing(dep string, stack []string, missing *missing) {
+func (dp *Pool) _checkMissing(dep string, stack []string, missing *missing, noDeps, noCheckDeps bool) {
 	if missing.Good.Get(dep) {
 		return
 	}
@@ -218,14 +218,15 @@ func (dp *Pool) _checkMissing(dep string, stack []string, missing *missing) {
 	aurPkg := dp.findSatisfierAur(dep)
 	if aurPkg != nil {
 		missing.Good.Set(dep)
-		for _, deps := range [3][]string{aurPkg.Depends, aurPkg.MakeDepends, aurPkg.CheckDepends} {
+		combinedDepList := ComputeCombinedDepList(aurPkg, noDeps, noCheckDeps)
+		for _, deps := range combinedDepList {
 			for _, aurDep := range deps {
 				if dp.AlpmExecutor.LocalSatisfierExists(aurDep) {
 					missing.Good.Set(aurDep)
 					continue
 				}
 
-				dp._checkMissing(aurDep, append(stack, aurPkg.Name), missing)
+				dp._checkMissing(aurDep, append(stack, aurPkg.Name), missing, noDeps, noCheckDeps)
 			}
 		}
 
@@ -235,13 +236,18 @@ func (dp *Pool) _checkMissing(dep string, stack []string, missing *missing) {
 	repoPkg := dp.findSatisfierRepo(dep)
 	if 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)
+			dp._checkMissing(dep.String(), append(stack, repoPkg.Name()), missing, noDeps, noCheckDeps)
 		}
 
 		return
@@ -272,18 +278,14 @@ func stringSliceEqual(a, b []string) bool {
 	return true
 }
 
-func (dp *Pool) CheckMissing(noDeps bool) error {
-	if noDeps {
-		return nil
-	}
-
+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)
+		dp._checkMissing(target.DepString(), make([]string, 0), missing, noDeps, noCheckDeps)
 	}
 
 	if len(missing.Missing) == 0 {

pkg/dep/depOrder.go

@@ -23,19 +23,19 @@ func makeOrder() *Order {
 	}
 }
 
-func GetOrder(dp *Pool) *Order {
+func GetOrder(dp *Pool, noDeps, noCheckDeps bool) *Order {
 	do := makeOrder()
 
 	for _, target := range dp.Targets {
 		dep := target.DepString()
 		aurPkg := dp.Aur[dep]
 		if aurPkg != nil && pkgSatisfies(aurPkg.Name, aurPkg.Version, dep) {
-			do.orderPkgAur(aurPkg, dp, true)
+			do.orderPkgAur(aurPkg, dp, true, noDeps, noCheckDeps)
 		}
 
 		aurPkg = dp.findSatisfierAur(dep)
 		if aurPkg != nil {
-			do.orderPkgAur(aurPkg, dp, true)
+			do.orderPkgAur(aurPkg, dp, true, noDeps, noCheckDeps)
 		}
 
 		repoPkg := dp.findSatisfierRepo(dep)
@@ -47,17 +47,17 @@ func GetOrder(dp *Pool) *Order {
 	return do
 }
 
-func (do *Order) orderPkgAur(pkg *rpc.Pkg, dp *Pool, runtime bool) {
+func (do *Order) orderPkgAur(pkg *rpc.Pkg, dp *Pool, runtime, noDeps, noCheckDeps bool) {
 	if runtime {
 		do.Runtime.Set(pkg.Name)
 	}
 	delete(dp.Aur, pkg.Name)
 
-	for i, deps := range [3][]string{pkg.Depends, pkg.MakeDepends, pkg.CheckDepends} {
+	for i, deps := range ComputeCombinedDepList(pkg, noDeps, noCheckDeps) {
 		for _, dep := range deps {
 			aurPkg := dp.findSatisfierAur(dep)
 			if aurPkg != nil {
-				do.orderPkgAur(aurPkg, dp, runtime && i == 0)
+				do.orderPkgAur(aurPkg, dp, runtime && i == 0, noDeps, noCheckDeps)
 			}
 
 			repoPkg := dp.findSatisfierRepo(dep)

pkg/dep/depPool.go

@@ -10,6 +10,7 @@ import (
 	"sync"
 
 	"github.com/leonelquinteros/gotext"
+	"github.com/mikkeloscar/aur"
 
 	"github.com/Jguer/yay/v10/pkg/db"
 	"github.com/Jguer/yay/v10/pkg/query"
@@ -78,7 +79,7 @@ func makePool(dbExecutor db.Executor) *Pool {
 // Includes db/ prefixes and group installs
 func (dp *Pool) ResolveTargets(pkgs []string,
 	mode settings.TargetMode,
-	ignoreProviders, noConfirm, provides bool, rebuild string, splitN int, noDeps bool) error {
+	ignoreProviders, noConfirm, provides bool, rebuild string, splitN int, noDeps, noCheckDeps bool) error {
 	// RPC requests are slow
 	// Combine as many AUR package requests as possible into a single RPC
 	// call
@@ -147,7 +148,7 @@ func (dp *Pool) ResolveTargets(pkgs []string,
 	}
 
 	if len(aurTargets) > 0 && (mode == settings.ModeAny || mode == settings.ModeAUR) {
-		return dp.resolveAURPackages(aurTargets, true, ignoreProviders, noConfirm, provides, rebuild, splitN, noDeps)
+		return dp.resolveAURPackages(aurTargets, true, ignoreProviders, noConfirm, provides, rebuild, splitN, noDeps, noCheckDeps)
 	}
 
 	return nil
@@ -258,9 +259,22 @@ func (dp *Pool) cacheAURPackages(_pkgs stringset.StringSet, provides bool, split
 	return nil
 }
 
+func ComputeCombinedDepList(pkg *aur.Pkg, noDeps, noCheckDeps bool) [][]string {
+	combinedDepList := [][]string{pkg.MakeDepends}
+	if !noDeps {
+		combinedDepList = append(combinedDepList, pkg.Depends)
+	}
+
+	if !noCheckDeps {
+		combinedDepList = append(combinedDepList, pkg.CheckDepends)
+	}
+
+	return combinedDepList
+}
+
 func (dp *Pool) resolveAURPackages(pkgs stringset.StringSet,
 	explicit, ignoreProviders, noConfirm, provides bool,
-	rebuild string, splitN int, noDeps bool) error {
+	rebuild string, splitN int, noDeps, noCheckDeps bool) error {
 	newPackages := make(stringset.StringSet)
 	newAURPackages := make(stringset.StringSet)
 
@@ -289,13 +303,7 @@ func (dp *Pool) resolveAURPackages(pkgs stringset.StringSet,
 		}
 		dp.Aur[pkg.Name] = pkg
 
-		var combinedDepList [][]string
-		if noDeps {
-			combinedDepList = [][]string{pkg.MakeDepends, pkg.CheckDepends}
-		} else {
-			combinedDepList = [][]string{pkg.Depends, pkg.MakeDepends, pkg.CheckDepends}
-		}
-
+		combinedDepList := ComputeCombinedDepList(pkg, noDeps, noCheckDeps)
 		for _, deps := range combinedDepList {
 			for _, dep := range deps {
 				newPackages.Set(dep)
@@ -327,7 +335,7 @@ func (dp *Pool) resolveAURPackages(pkgs stringset.StringSet,
 		newAURPackages.Set(dep)
 	}
 
-	err = dp.resolveAURPackages(newAURPackages, false, ignoreProviders, noConfirm, provides, rebuild, splitN, noDeps)
+	err = dp.resolveAURPackages(newAURPackages, false, ignoreProviders, noConfirm, provides, rebuild, splitN, noDeps, noCheckDeps)
 	return err
 }
 
@@ -360,11 +368,11 @@ func GetPool(pkgs []string,
 	dbExecutor db.Executor,
 	mode settings.TargetMode,
 	ignoreProviders, noConfirm, provides bool,
-	rebuild string, splitN int, noDeps bool) (*Pool, error) {
+	rebuild string, splitN int, noDeps bool, noCheckDeps bool) (*Pool, error) {
 	dp := makePool(dbExecutor)
 
 	dp.Warnings = warnings
-	err := dp.ResolveTargets(pkgs, mode, ignoreProviders, noConfirm, provides, rebuild, splitN, noDeps)
+	err := dp.ResolveTargets(pkgs, mode, ignoreProviders, noConfirm, provides, rebuild, splitN, noDeps, noCheckDeps)
 
 	return dp, err
 }