add dep graph for local install

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)
-		}
-	}
-}