add dep graph for local install

install.go

@@ -423,20 +423,6 @@ func earlyRefresh(ctx context.Context, cmdArgs *parser.Arguments) error {
 		arguments, config.Runtime.Mode, settings.NoConfirm))
 }
 
-func alpmArchIsSupported(alpmArch []string, arch string) bool {
-	if arch == "any" {
-		return true
-	}
-
-	for _, a := range alpmArch {
-		if a == arch {
-			return true
-		}
-	}
-
-	return false
-}
-
 func getIncompatible(bases []dep.Base, srcinfos map[string]*gosrc.Srcinfo, dbExecutor db.Executor) (stringset.StringSet, error) {
 	incompatible := make(stringset.StringSet)
 	basesMap := make(map[string]dep.Base)
@@ -449,7 +435,7 @@ func getIncompatible(bases []dep.Base, srcinfos map[string]*gosrc.Srcinfo, dbExe
 nextpkg:
 	for _, base := range bases {
 		for _, arch := range srcinfos[base.Pkgbase()].Arch {
-			if alpmArchIsSupported(alpmArch, arch) {
+			if db.ArchIsSupported(alpmArch, arch) {
 				continue nextpkg
 			}
 		}

local_install.go

@@ -2,97 +2,27 @@ package main
 
 import (
 	"context"
+	"fmt"
 	"os"
 	"path/filepath"
-	"strings"
 
-	"github.com/Jguer/aur"
 	"github.com/Jguer/yay/v11/pkg/db"
 	"github.com/Jguer/yay/v11/pkg/dep"
 	"github.com/Jguer/yay/v11/pkg/metadata"
+	"github.com/Jguer/yay/v11/pkg/settings"
 	"github.com/Jguer/yay/v11/pkg/settings/parser"
-	"github.com/Jguer/yay/v11/pkg/topo"
 	gosrc "github.com/Morganamilo/go-srcinfo"
 	"github.com/leonelquinteros/gotext"
 	"github.com/pkg/errors"
 )
 
-func archStringToString(alpmArches []string, archString []gosrc.ArchString) []string {
-	pkgs := make([]string, 0, len(archString))
-
-	for _, arch := range archString {
-		if alpmArchIsSupported(alpmArches, arch.Arch) {
-			pkgs = append(pkgs, arch.Value)
-		}
-	}
-
-	return pkgs
-}
-
-func makeAURPKGFromSrcinfo(dbExecutor db.Executor, srcInfo *gosrc.Srcinfo) ([]aur.Pkg, error) {
-	pkgs := make([]aur.Pkg, 0, 1)
-
-	alpmArch, err := dbExecutor.AlpmArchitectures()
-	if err != nil {
-		return nil, err
-	}
-
-	alpmArch = append(alpmArch, "") // srcinfo assumes no value as ""
-
-	for _, pkg := range srcInfo.Packages {
-		pkgs = append(pkgs, aur.Pkg{
-			ID:            0,
-			Name:          pkg.Pkgname,
-			PackageBaseID: 0,
-			PackageBase:   srcInfo.Pkgbase,
-			Version:       srcInfo.Version(),
-			Description:   pkg.Pkgdesc,
-			URL:           pkg.URL,
-			Depends:       append(archStringToString(alpmArch, pkg.Depends), archStringToString(alpmArch, srcInfo.Package.Depends)...),
-			MakeDepends:   archStringToString(alpmArch, srcInfo.PackageBase.MakeDepends),
-			CheckDepends:  archStringToString(alpmArch, srcInfo.PackageBase.CheckDepends),
-			Conflicts:     append(archStringToString(alpmArch, pkg.Conflicts), archStringToString(alpmArch, srcInfo.Package.Conflicts)...),
-			Provides:      append(archStringToString(alpmArch, pkg.Provides), archStringToString(alpmArch, srcInfo.Package.Provides)...),
-			Replaces:      append(archStringToString(alpmArch, pkg.Replaces), archStringToString(alpmArch, srcInfo.Package.Replaces)...),
-			OptDepends:    []string{},
-			Groups:        pkg.Groups,
-			License:       pkg.License,
-			Keywords:      []string{},
-		})
-	}
-
-	return pkgs, nil
-}
-
-func splitDep(dep string) (pkg, mod, ver string) {
-	split := strings.FieldsFunc(dep, func(c rune) bool {
-		match := c == '>' || c == '<' || c == '='
-
-		if match {
-			mod += string(c)
-		}
-
-		return match
-	})
-
-	if len(split) == 0 {
-		return "", "", ""
-	}
-
-	if len(split) == 1 {
-		return split[0], "", ""
-	}
-
-	return split[0], mod, split[1]
-}
-
 func installLocalPKGBUILD(
 	ctx context.Context,
 	cmdArgs *parser.Arguments,
 	dbExecutor db.Executor,
 	ignoreProviders bool,
 ) error {
-	aurCache, err := metadata.NewAURCache("aur.json")
+	aurCache, err := metadata.NewAURCache(filepath.Join(config.BuildDir, "aur.json"))
 	if err != nil {
 		return errors.Wrap(err, gotext.Get("failed to retrieve aur Cache"))
 	}
@@ -115,19 +45,14 @@ func installLocalPKGBUILD(
 		return errors.Wrap(err, gotext.Get("failed to parse .SRCINFO"))
 	}
 
-	aurPkgs, err := makeAURPKGFromSrcinfo(dbExecutor, pkgbuild)
+	grapher := dep.NewGrapher(dbExecutor, aurCache, false, settings.NoConfirm, os.Stdout)
+
+	graph, err := grapher.GraphFromSrcInfo(pkgbuild)
 	if err != nil {
 		return err
 	}
 
-	graph := topo.New[string]()
-
-	for _, pkg := range aurPkgs {
-		depSlice := dep.ComputeCombinedDepList(&pkg, false, false)
-		addNodes(dbExecutor, aurCache, pkg.Name, pkg.PackageBase, depSlice, graph)
-	}
-
-	// fmt.Println(graph)
+	fmt.Println(graph)
 	// aurCache.DebugInfo()
 
 	// topoSorted := graph.TopoSortedLayers()
@@ -135,48 +60,3 @@ func installLocalPKGBUILD(
 
 	return nil
 }
-
-func addNodes(dbExecutor db.Executor, aurCache *metadata.AURCache, pkgName string, pkgBase string, deps []string, graph *topo.Graph[string]) {
-	graph.AddNode(pkgBase)
-	graph.Alias(pkgBase, pkgName)
-	graph.SetNodeInfo(pkgBase, &topo.NodeInfo{Color: "blue"})
-
-	for _, depString := range deps {
-		depName, _, _ := splitDep(depString)
-
-		if dbExecutor.LocalSatisfierExists(depString) {
-			continue
-		} else if graph.Exists(depName) {
-			graph.DependOn(depName, pkgBase)
-			continue
-		}
-
-		graph.DependOn(depName, pkgBase)
-
-		// Check ALPM
-		if alpmPkg := dbExecutor.SyncSatisfier(depString); alpmPkg != nil {
-			newDeps := alpmPkg.Depends().Slice()
-			newDepsSlice := make([]string, 0, len(newDeps))
-
-			for _, newDep := range newDeps {
-				newDepsSlice = append(newDepsSlice, newDep.Name)
-			}
-
-			if len(newDeps) == 0 {
-				continue
-			}
-
-			addNodes(dbExecutor, aurCache, alpmPkg.Name(), alpmPkg.Base(), newDepsSlice, graph)
-			// Check AUR
-		} else if aurPkgs, _ := aurCache.FindDep(depName); len(aurPkgs) != 0 {
-			pkg := aurPkgs[0]
-			newDeps := dep.ComputeCombinedDepList(pkg, false, false)
-
-			if len(newDeps) == 0 {
-				continue
-			}
-
-			addNodes(dbExecutor, aurCache, pkg.PackageBase, pkg.Name, newDeps, graph)
-		}
-	}
-}

pkg/db/types.go

@@ -0,0 +1,15 @@
+package db
+
+func ArchIsSupported(alpmArch []string, arch string) bool {
+	if arch == "any" {
+		return true
+	}
+
+	for _, a := range alpmArch {
+		if a == arch {
+			return true
+		}
+	}
+
+	return false
+}

pkg/dep/depGraph.go

@@ -11,6 +11,8 @@ import (
 	aur "github.com/Jguer/yay/v11/pkg/query"
 	"github.com/Jguer/yay/v11/pkg/text"
 	"github.com/Jguer/yay/v11/pkg/topo"
+
+	gosrc "github.com/Morganamilo/go-srcinfo"
 	"github.com/leonelquinteros/gotext"
 )
 
@@ -32,6 +34,21 @@ func NewGrapher(dbExecutor db.Executor, aurCache *metadata.AURCache, fullGraph,
 	}
 }
 
+func (g *Grapher) GraphFromSrcInfo(pkgbuild *gosrc.Srcinfo) (*topo.Graph[string], error) {
+	graph := topo.New[string]()
+	aurPkgs, err := makeAURPKGFromSrcinfo(g.dbExecutor, pkgbuild)
+	if err != nil {
+		return nil, err
+	}
+
+	for _, pkg := range aurPkgs {
+		depSlice := ComputeCombinedDepList(&pkg, false, false)
+		g.addNodes(graph, pkg.Name, depSlice)
+	}
+
+	return graph, nil
+}
+
 func (g *Grapher) GraphFromAURCache(targets []string) (*topo.Graph[string], error) {
 	graph := topo.New[string]()
 
@@ -175,3 +192,50 @@ func provideMenu(w io.Writer, dep string, options []*aur.Pkg, noConfirm bool) *a
 
 	return nil
 }
+
+func makeAURPKGFromSrcinfo(dbExecutor db.Executor, srcInfo *gosrc.Srcinfo) ([]aur.Pkg, error) {
+	pkgs := make([]aur.Pkg, 0, 1)
+
+	alpmArch, err := dbExecutor.AlpmArchitectures()
+	if err != nil {
+		return nil, err
+	}
+
+	alpmArch = append(alpmArch, "") // srcinfo assumes no value as ""
+
+	for _, pkg := range srcInfo.Packages {
+		pkgs = append(pkgs, aur.Pkg{
+			ID:            0,
+			Name:          pkg.Pkgname,
+			PackageBaseID: 0,
+			PackageBase:   srcInfo.Pkgbase,
+			Version:       srcInfo.Version(),
+			Description:   pkg.Pkgdesc,
+			URL:           pkg.URL,
+			Depends:       append(archStringToString(alpmArch, pkg.Depends), archStringToString(alpmArch, srcInfo.Package.Depends)...),
+			MakeDepends:   archStringToString(alpmArch, srcInfo.PackageBase.MakeDepends),
+			CheckDepends:  archStringToString(alpmArch, srcInfo.PackageBase.CheckDepends),
+			Conflicts:     append(archStringToString(alpmArch, pkg.Conflicts), archStringToString(alpmArch, srcInfo.Package.Conflicts)...),
+			Provides:      append(archStringToString(alpmArch, pkg.Provides), archStringToString(alpmArch, srcInfo.Package.Provides)...),
+			Replaces:      append(archStringToString(alpmArch, pkg.Replaces), archStringToString(alpmArch, srcInfo.Package.Replaces)...),
+			OptDepends:    []string{},
+			Groups:        pkg.Groups,
+			License:       pkg.License,
+			Keywords:      []string{},
+		})
+	}
+
+	return pkgs, nil
+}
+
+func archStringToString(alpmArches []string, archString []gosrc.ArchString) []string {
+	pkgs := make([]string, 0, len(archString))
+
+	for _, arch := range archString {
+		if db.ArchIsSupported(alpmArches, arch.Arch) {
+			pkgs = append(pkgs, arch.Value)
+		}
+	}
+
+	return pkgs
+}