add repo install

aur_source.go

@@ -9,7 +9,6 @@ import (
 
 	"github.com/leonelquinteros/gotext"
 
-	"github.com/Jguer/yay/v11/pkg/dep"
 	"github.com/Jguer/yay/v11/pkg/multierror"
 	"github.com/Jguer/yay/v11/pkg/settings/exe"
 	"github.com/Jguer/yay/v11/pkg/stringset"
@@ -32,7 +31,8 @@ func (e *ErrDownloadSource) Unwrap() error {
 }
 
 func downloadPKGBUILDSource(ctx context.Context, cmdBuilder exe.ICmdBuilder, dest,
-	base string, incompatible stringset.StringSet) (err error) {
+	base string, incompatible stringset.StringSet,
+) error {
 	dir := filepath.Join(dest, base)
 	args := []string{"--verifysource", "-Ccf"}
 
@@ -40,7 +40,7 @@ func downloadPKGBUILDSource(ctx context.Context, cmdBuilder exe.ICmdBuilder, des
 		args = append(args, "--ignorearch")
 	}
 
-	err = cmdBuilder.Show(
+	err := cmdBuilder.Show(
 		cmdBuilder.BuildMakepkgCmd(ctx, dir, args...))
 	if err != nil {
 		return ErrDownloadSource{inner: err, pkgName: base, errOut: ""}
@@ -51,7 +51,8 @@ func downloadPKGBUILDSource(ctx context.Context, cmdBuilder exe.ICmdBuilder, des
 
 func downloadPKGBUILDSourceWorker(ctx context.Context, wg *sync.WaitGroup, dest string,
 	cBase <-chan string, valOut chan<- string, errOut chan<- error,
-	cmdBuilder exe.ICmdBuilder, incompatible stringset.StringSet) {
+	cmdBuilder exe.ICmdBuilder, incompatible stringset.StringSet,
+) {
 	for base := range cBase {
 		err := downloadPKGBUILDSource(ctx, cmdBuilder, dest, base, incompatible)
 		if err != nil {
@@ -65,9 +66,14 @@ func downloadPKGBUILDSourceWorker(ctx context.Context, wg *sync.WaitGroup, dest
 }
 
 func downloadPKGBUILDSourceFanout(ctx context.Context, cmdBuilder exe.ICmdBuilder, dest string,
-	bases []dep.Base, incompatible stringset.StringSet, maxConcurrentDownloads int) error {
+	bases []string, incompatible stringset.StringSet, maxConcurrentDownloads int,
+) error {
+	if len(bases) == 0 {
+		return nil // no work to do
+	}
+
 	if len(bases) == 1 {
-		return downloadPKGBUILDSource(ctx, cmdBuilder, dest, bases[0].Pkgbase(), incompatible)
+		return downloadPKGBUILDSource(ctx, cmdBuilder, dest, bases[0], incompatible)
 	}
 
 	var (
@@ -84,7 +90,7 @@ func downloadPKGBUILDSourceFanout(ctx context.Context, cmdBuilder exe.ICmdBuilde
 
 	go func() {
 		for _, base := range bases {
-			c <- base.Pkgbase()
+			c <- base
 		}
 
 		close(c)

aur_source_test.go

@@ -9,9 +9,6 @@ import (
 
 	"github.com/stretchr/testify/assert"
 
-	"github.com/Jguer/aur"
-
-	"github.com/Jguer/yay/v11/pkg/dep"
 	"github.com/Jguer/yay/v11/pkg/multierror"
 	"github.com/Jguer/yay/v11/pkg/settings/exe"
 	"github.com/Jguer/yay/v11/pkg/stringset"
@@ -84,14 +81,7 @@ func Test_downloadPKGBUILDSourceError(t *testing.T) {
 func Test_downloadPKGBUILDSourceFanout(t *testing.T) {
 	t.Parallel()
 
-	bases := []dep.Base{
-		{&aur.Pkg{PackageBase: "yay"}},
-		{&aur.Pkg{PackageBase: "yay-bin"}},
-		{&aur.Pkg{PackageBase: "yay-git"}},
-		{&aur.Pkg{PackageBase: "yay-v11"}},
-		{&aur.Pkg{PackageBase: "yay-v12"}},
-	}
-
+	bases := []string{"yay", "yay-bin", "yay-git", "yay-v11", "yay-v12"}
 	for _, maxConcurrentDownloads := range []int{0, 3} {
 		t.Run(fmt.Sprintf("maxconcurrentdownloads set to %d", maxConcurrentDownloads), func(t *testing.T) {
 			cmdBuilder := &TestMakepkgBuilder{
@@ -122,9 +112,7 @@ func Test_downloadPKGBUILDSourceFanoutNoCC(t *testing.T) {
 		test: t,
 	}
 
-	bases := []dep.Base{
-		{&aur.Pkg{PackageBase: "yay"}},
-	}
+	bases := []string{"yay"}
 
 	err := downloadPKGBUILDSourceFanout(context.TODO(), cmdBuilder, "/tmp", bases, stringset.Make(), 0)
 	assert.NoError(t, err)
@@ -145,12 +133,12 @@ func Test_downloadPKGBUILDSourceFanoutError(t *testing.T) {
 		showError: &exec.ExitError{},
 	}
 
-	bases := []dep.Base{
-		{&aur.Pkg{PackageBase: "yay"}},
-		{&aur.Pkg{PackageBase: "yay-bin"}},
-		{&aur.Pkg{PackageBase: "yay-git"}},
-		{&aur.Pkg{PackageBase: "yay-v11"}},
-		{&aur.Pkg{PackageBase: "yay-v12"}},
+	bases := []string{
+		"yay",
+		"yay-bin",
+		"yay-git",
+		"yay-v11",
+		"yay-v12",
 	}
 
 	err := downloadPKGBUILDSourceFanout(context.TODO(), cmdBuilder, "/tmp", bases, stringset.Make(), 0)

cmd.go

@@ -330,7 +330,7 @@ func handleUpgrade(ctx context.Context,
 	config *settings.Configuration, dbExecutor db.Executor, cmdArgs *parser.Arguments,
 ) error {
 	if cmdArgs.ExistsArg("i", "install") {
-		return installLocalPKGBUILD(ctx, cmdArgs, dbExecutor, false)
+		return installLocalPKGBUILD(ctx, cmdArgs, dbExecutor)
 	}
 
 	return config.Runtime.CmdBuilder.Show(config.Runtime.CmdBuilder.BuildPacmanCmd(ctx,

install.go

@@ -330,8 +330,13 @@ func install(ctx context.Context, cmdArgs *parser.Arguments, dbExecutor db.Execu
 			config.AURURL, config.Runtime.CompletionPath, config.CompletionInterval, false)
 	}()
 
+	bases := make([]string, 0, len(do.Aur))
+	for _, base := range do.Aur {
+		bases = append(bases, base.Pkgbase())
+	}
+
 	if errP := downloadPKGBUILDSourceFanout(ctx, config.Runtime.CmdBuilder, config.BuildDir,
-		do.Aur, incompatible, config.MaxConcurrentDownloads); errP != nil {
+		bases, incompatible, config.MaxConcurrentDownloads); errP != nil {
 		text.Errorln(errP)
 	}
 

local_install.go

@@ -1,3 +1,5 @@
+// Experimental code for install local with dependency refactoring
+// Not at feature parity with install.go
 package main
 
 import (
@@ -8,19 +10,22 @@ import (
 
 	"github.com/Jguer/yay/v11/pkg/db"
 	"github.com/Jguer/yay/v11/pkg/dep"
+	"github.com/Jguer/yay/v11/pkg/download"
 	"github.com/Jguer/yay/v11/pkg/metadata"
 	"github.com/Jguer/yay/v11/pkg/settings"
+	"github.com/Jguer/yay/v11/pkg/settings/exe"
 	"github.com/Jguer/yay/v11/pkg/settings/parser"
 	gosrc "github.com/Morganamilo/go-srcinfo"
 	"github.com/leonelquinteros/gotext"
 	"github.com/pkg/errors"
 )
 
+var ErrInstallRepoPkgs = errors.New(gotext.Get("error installing repo packages"))
+
 func installLocalPKGBUILD(
 	ctx context.Context,
 	cmdArgs *parser.Arguments,
 	dbExecutor db.Executor,
-	ignoreProviders bool,
 ) error {
 	aurCache, err := metadata.NewAURCache(filepath.Join(config.BuildDir, "aur.json"))
 	if err != nil {
@@ -55,9 +60,37 @@ func installLocalPKGBUILD(
 	topoSorted := graph.TopoSortedLayerMap()
 	fmt.Println(topoSorted, len(topoSorted))
 
+	preparer := &Preparer{dbExecutor: dbExecutor, cmdBuilder: config.Runtime.CmdBuilder}
 	installer := &Installer{dbExecutor: dbExecutor}
 
-	installer.Install(ctx, topoSorted)
+	if err := preparer.PrepareWorkspace(ctx, topoSorted); err != nil {
+		return err
+	}
+
+	return installer.Install(ctx, cmdArgs, topoSorted)
+}
+
+type Preparer struct {
+	dbExecutor db.Executor
+	cmdBuilder exe.ICmdBuilder
+	aurBases   []string
+}
+
+func (preper *Preparer) PrepareWorkspace(ctx context.Context, targets []map[string]*dep.InstallInfo,
+) error {
+	for _, layer := range targets {
+		for pkgBase, info := range layer {
+			if info.Source == dep.AUR {
+				preper.aurBases = append(preper.aurBases, pkgBase)
+			}
+		}
+	}
+
+	_, errA := download.AURPKGBUILDRepos(ctx,
+		preper.cmdBuilder, preper.aurBases, config.AURURL, config.BuildDir, false)
+	if errA != nil {
+		return errA
+	}
 
 	return nil
 }
@@ -66,10 +99,10 @@ type Installer struct {
 	dbExecutor db.Executor
 }
 
-func (installer *Installer) Install(ctx context.Context, targets []map[string]*dep.InstallInfo) error {
+func (installer *Installer) Install(ctx context.Context, cmdArgs *parser.Arguments, targets []map[string]*dep.InstallInfo) error {
 	// Reorganize targets into layers of dependencies
 	for i := len(targets) - 1; i >= 0; i-- {
-		err := installer.handleLayer(ctx, targets[i])
+		err := installer.handleLayer(ctx, cmdArgs, targets[i])
 		if err != nil {
 			// rollback
 			return err
@@ -95,7 +128,7 @@ func (m *MapBySourceAndType) String() string {
 	return s
 }
 
-func (installer *Installer) handleLayer(ctx context.Context, layer map[string]*dep.InstallInfo) error {
+func (installer *Installer) handleLayer(ctx context.Context, cmdArgs *parser.Arguments, layer map[string]*dep.InstallInfo) error {
 	// Install layer
 	depByTypeAndReason := make(MapBySourceAndType)
 	for name, info := range layer {
@@ -108,5 +141,65 @@ func (installer *Installer) handleLayer(ctx context.Context, layer map[string]*d
 
 	fmt.Printf("%v\n", depByTypeAndReason)
 
+	syncDeps, syncExp := make([]string, 0), make([]string, 0)
+	repoTargets := make([]string, 0)
+
+	for source, reasons := range depByTypeAndReason {
+		switch source {
+		case dep.AUR:
+		case dep.Sync:
+			for reason, names := range reasons {
+				switch reason {
+				case dep.Explicit:
+					if cmdArgs.ExistsArg("asdeps", "asdep") {
+						syncDeps = append(syncDeps, names...)
+					} else {
+						syncExp = append(syncExp, names...)
+					}
+				case dep.CheckDep:
+					fallthrough
+				case dep.MakeDep:
+					fallthrough
+				case dep.Dep:
+					syncDeps = append(syncDeps, names...)
+				}
+
+				repoTargets = append(repoTargets, names...)
+			}
+		}
+	}
+
+	fmt.Println(syncDeps, syncExp)
+
+	errShow := installer.installRepoPackages(ctx, cmdArgs, repoTargets, syncDeps, syncExp)
+	if errShow != nil {
+		return ErrInstallRepoPkgs
+	}
+
 	return nil
 }
+
+func (*Installer) installRepoPackages(ctx context.Context, cmdArgs *parser.Arguments,
+	repoTargets, // all repo targets
+	syncDeps, // repo targets that are deps
+	syncExp []string, // repo targets that are exp
+) error {
+	arguments := cmdArgs.Copy()
+	arguments.DelArg("asdeps", "asdep")
+	arguments.DelArg("asexplicit", "asexp")
+	arguments.DelArg("i", "install")
+	arguments.Op = "S"
+	arguments.ClearTargets()
+	arguments.AddTarget(repoTargets...)
+	errShow := config.Runtime.CmdBuilder.Show(config.Runtime.CmdBuilder.BuildPacmanCmd(ctx,
+		arguments, config.Runtime.Mode, settings.NoConfirm))
+
+	if errD := asdeps(ctx, cmdArgs, syncDeps); errD != nil {
+		return errD
+	}
+
+	if errE := asexp(ctx, cmdArgs, syncExp); errE != nil {
+		return errE
+	}
+	return errShow
+}