wip

search handlers wip

pkg/dep/dep_graph.go

@@ -3,7 +3,6 @@ package dep
 import (
 	"context"
 	"fmt"
-	"path/filepath"
 	"strconv"
 
 	aurc "github.com/Jguer/aur"
@@ -102,7 +101,7 @@ var colorMap = map[Reason]string{
 }
 
 type SourceHandler interface {
-	Graph(ctx context.Context, graph *topo.Graph[string, *InstallInfo], targets []Target) (*topo.Graph[string, *InstallInfo], error)
+	Graph(ctx context.Context, graph *topo.Graph[string, *InstallInfo]) error
 	Test(target Target) bool
 }
 
@@ -126,7 +125,7 @@ func NewGrapher(dbExecutor db.Executor, cfg *settings.Configuration, aurCache au
 	fullGraph, noConfirm, noDeps, noCheckDeps, needed bool,
 	logger *text.Logger,
 ) *Grapher {
-	return &Grapher{
+	grapher := &Grapher{
 		dbExecutor:    dbExecutor,
 		cfg:           cfg,
 		aurClient:     aurCache,
@@ -140,6 +139,34 @@ func NewGrapher(dbExecutor db.Executor, cfg *settings.Configuration, aurCache au
 		logger:        logger,
 		handlers:      make(map[string][]SourceHandler),
 	}
+
+	grapher.RegisterSourceHandler(&AllSyncHandler{
+		log:          logger,
+		db:           dbExecutor,
+		foundTargets: []alpm.IPackage{},
+	}, "")
+	grapher.RegisterSourceHandler(&AllSyncGroupHandler{
+		db:           dbExecutor,
+		foundTargets: []Target{},
+	}, "")
+
+	grapher.RegisterSourceHandler(&SRCINFOHandler{
+		log:          logger,
+		db:           dbExecutor,
+		cmdBuilder:   cmdBuilder,
+		foundTargets: []string{},
+	}, sourceCacheSRCINFO)
+
+	for _, repo := range grapher.dbExecutor.Repos() {
+		grapher.RegisterSourceHandler(&SyncHandler{
+			log:         logger,
+			db:          dbExecutor,
+			foundPkgs:   []alpm.IPackage{},
+			foundGroups: []Target{},
+		}, repo)
+	}
+
+	return grapher
 }
 
 func NewGraph() *topo.Graph[string, *InstallInfo] {
@@ -158,54 +185,33 @@ func (g *Grapher) GraphFromTargets(ctx context.Context,
 	}
 
 	aurTargets := make([]string, 0, len(targets))
-	srcinfoTargets := make([]string, 0)
 
+	sources := mapset.NewThreadUnsafeSetFromMapKeys[string, []SourceHandler](g.handlers)
+
+nextTarget:
 	for _, targetString := range targets {
 		target := ToTarget(targetString)
 
-		switch target.DB {
-		case "": // unspecified db
-			if pkg := g.dbExecutor.SyncSatisfier(target.Name); pkg != nil {
-				GraphSyncPkg(ctx, g.dbExecutor, graph, g.logger, pkg, nil)
-
-				continue
+		for _, handler := range g.handlers[target.DB] {
+			if handler.Test(target) {
+				continue nextTarget
 			}
+		}
 
-			groupPackages := g.dbExecutor.PackagesFromGroup(target.Name)
-			if len(groupPackages) > 0 {
-				dbName := groupPackages[0].DB().Name()
-				g.GraphSyncGroup(ctx, graph, target.Name, dbName)
-
-				continue
-			}
+		g.logger.Errorln(gotext.Get("No package found for"), " ", target)
 
-			fallthrough
+		switch target.DB {
 		case sourceAUR:
 			aurTargets = append(aurTargets, target.Name)
-		case sourceCacheSRCINFO:
-			srcinfoTargets = append(srcinfoTargets, filepath.Join(g.cfg.BuildDir, target.Name))
 		default:
-			pkg, err := g.dbExecutor.SatisfierFromDB(target.Name, target.DB)
-			if err != nil {
-				return nil, err
-			}
-			if pkg != nil {
-				GraphSyncPkg(ctx, g.dbExecutor, graph, g.logger, pkg, nil)
-
-				continue
-			}
-
-			groupPackages, err := g.dbExecutor.PackagesFromGroupAndDB(target.Name, target.DB)
-			if err != nil {
-				return nil, err
-			}
-			if len(groupPackages) > 0 {
-				g.GraphSyncGroup(ctx, graph, target.Name, target.DB)
+		}
+	}
 
-				continue
+	for source := range sources.Iter() {
+		for _, handler := range g.handlers[source] {
+			if err := handler.Graph(ctx, graph); err != nil {
+				g.logger.Errorln(gotext.Get("Error graphing targets"), ":", err)
 			}
-
-			g.logger.Errorln(gotext.Get("No package found for"), " ", target)
 		}
 	}
 
@@ -215,11 +221,6 @@ func (g *Grapher) GraphFromTargets(ctx context.Context,
 		return nil, errA
 	}
 
-	graph, errS := g.GraphFromSrcInfoDirs(ctx, graph, srcinfoTargets)
-	if errS != nil {
-		return nil, errS
-	}
-
 	return graph, nil
 }
 
@@ -255,10 +256,10 @@ func (g *Grapher) pickSrcInfoPkgs(pkgs []*aurc.Pkg) ([]*aurc.Pkg, error) {
 	return final, nil
 }
 
-func (g *Grapher) addAurPkgProvides(pkg *aurc.Pkg, graph *topo.Graph[string, *InstallInfo]) {
+func addAurPkgProvides(logger *text.Logger, pkg *aurc.Pkg, graph *topo.Graph[string, *InstallInfo]) {
 	for i := range pkg.Provides {
 		depName, mod, version := splitDep(pkg.Provides[i])
-		g.logger.Debugln(pkg.String() + " provides: " + depName)
+		logger.Debugln(pkg.String() + " provides: " + depName)
 		graph.Provides(depName, &alpm.Depend{
 			Name:    depName,
 			Version: version,
@@ -287,73 +288,6 @@ func (g *Grapher) addDepNodes(ctx context.Context, pkg *aur.Pkg, graph *topo.Gra
 	}
 }
 
-func GraphSyncPkg(ctx context.Context, dbExecutor db.Executor,
-	graph *topo.Graph[string, *InstallInfo], logger *text.Logger,
-	pkg alpm.IPackage, upgradeInfo *db.SyncUpgrade,
-) *topo.Graph[string, *InstallInfo] {
-	if graph == nil {
-		graph = NewGraph()
-	}
-
-	graph.AddNode(pkg.Name())
-	_ = pkg.Provides().ForEach(func(p *alpm.Depend) error {
-		logger.Debugln(pkg.Name() + " provides: " + p.String())
-		graph.Provides(p.Name, p, pkg.Name())
-		return nil
-	})
-
-	dbName := pkg.DB().Name()
-	info := &InstallInfo{
-		Source:     Sync,
-		Reason:     Explicit,
-		Version:    pkg.Version(),
-		SyncDBName: &dbName,
-	}
-
-	if upgradeInfo == nil {
-		if localPkg := dbExecutor.LocalPackage(pkg.Name()); localPkg != nil {
-			info.Reason = Reason(localPkg.Reason())
-		}
-	} else {
-		info.Upgrade = true
-		info.Reason = Reason(upgradeInfo.Reason)
-		info.LocalVersion = upgradeInfo.LocalVersion
-	}
-
-	validateAndSetNodeInfo(graph, pkg.Name(), &topo.NodeInfo[*InstallInfo]{
-		Color:      colorMap[info.Reason],
-		Background: bgColorMap[info.Source],
-		Value:      info,
-	})
-
-	return graph
-}
-
-func (g *Grapher) GraphSyncGroup(ctx context.Context,
-	graph *topo.Graph[string, *InstallInfo],
-	groupName, dbName string,
-) *topo.Graph[string, *InstallInfo] {
-	if graph == nil {
-		graph = NewGraph()
-	}
-
-	graph.AddNode(groupName)
-
-	validateAndSetNodeInfo(graph, groupName, &topo.NodeInfo[*InstallInfo]{
-		Color:      colorMap[Explicit],
-		Background: bgColorMap[Sync],
-		Value: &InstallInfo{
-			Source:     Sync,
-			Reason:     Explicit,
-			Version:    "",
-			SyncDBName: &dbName,
-			IsGroup:    true,
-		},
-	})
-
-	return graph
-}
-
 func (g *Grapher) GraphAURTarget(ctx context.Context,
 	graph *topo.Graph[string, *InstallInfo],
 	pkg *aurc.Pkg, instalInfo *InstallInfo,

pkg/dep/srcinfo.go

@@ -11,13 +11,41 @@ import (
 	gosrc "github.com/Morganamilo/go-srcinfo"
 	"github.com/leonelquinteros/gotext"
 
+	"github.com/Jguer/yay/v12/pkg/db"
 	"github.com/Jguer/yay/v12/pkg/dep/topo"
+	"github.com/Jguer/yay/v12/pkg/settings"
 	"github.com/Jguer/yay/v12/pkg/settings/exe"
+	"github.com/Jguer/yay/v12/pkg/text"
 )
 
 var ErrNoBuildFiles = errors.New(gotext.Get("cannot find PKGBUILD and .SRCINFO in directory"))
 
-func (g *Grapher) GraphFromSrcInfoDirs(ctx context.Context, graph *topo.Graph[string, *InstallInfo],
+var _ SourceHandler = &SRCINFOHandler{}
+
+type SRCINFOHandler struct {
+	cfg          *settings.Configuration
+	log          *text.Logger
+	db           db.Executor
+	cmdBuilder   exe.ICmdBuilder
+	foundTargets []string
+}
+
+func (g *SRCINFOHandler) Test(target Target) bool {
+	path := filepath.Join(g.cfg.BuildDir, target.Name)
+	if _, err := os.Stat(path); err == nil {
+		g.foundTargets = append(g.foundTargets, path)
+		return true
+	}
+
+	return false
+}
+
+func (g *SRCINFOHandler) Graph(ctx context.Context, graph *topo.Graph[string, *InstallInfo]) error {
+	_, err := g.GraphFromSrcInfoDirs(ctx, graph, g.foundTargets)
+	return err
+}
+
+func (g *SRCINFOHandler) GraphFromSrcInfoDirs(ctx context.Context, graph *topo.Graph[string, *InstallInfo],
 	srcInfosDirs []string,
 ) (*topo.Graph[string, *InstallInfo], error) {
 	if graph == nil {
@@ -42,7 +70,7 @@ func (g *Grapher) GraphFromSrcInfoDirs(ctx context.Context, graph *topo.Graph[st
 	for pkgBuildDir, pkgbuild := range srcInfos {
 		pkgBuildDir := pkgBuildDir
 
-		aurPkgs, err := makeAURPKGFromSrcinfo(g.dbExecutor, pkgbuild)
+		aurPkgs, err := makeAURPKGFromSrcinfo(g.db, pkgbuild)
 		if err != nil {
 			return nil, err
 		}
@@ -59,13 +87,13 @@ func (g *Grapher) GraphFromSrcInfoDirs(ctx context.Context, graph *topo.Graph[st
 			pkg := pkg
 
 			reason := Explicit
-			if pkg := g.dbExecutor.LocalPackage(pkg.Name); pkg != nil {
+			if pkg := g.db.LocalPackage(pkg.Name); pkg != nil {
 				reason = Reason(pkg.Reason())
 			}
 
 			graph.AddNode(pkg.Name)
 
-			g.addAurPkgProvides(pkg, graph)
+			addAurPkgProvides(g.log, pkg, graph)
 
 			validateAndSetNodeInfo(graph, pkg.Name, &topo.NodeInfo[*InstallInfo]{
 				Color:      colorMap[reason],

pkg/dep/sync.go

@@ -0,0 +1,172 @@
+package dep
+
+import (
+	"context"
+
+	"github.com/Jguer/go-alpm/v2"
+
+	"github.com/Jguer/yay/v12/pkg/db"
+	"github.com/Jguer/yay/v12/pkg/dep/topo"
+	"github.com/Jguer/yay/v12/pkg/text"
+)
+
+var (
+	_ SourceHandler = &AllSyncHandler{}
+	_ SourceHandler = &AllSyncGroupHandler{}
+)
+
+type AllSyncHandler struct {
+	log          *text.Logger
+	db           db.Executor
+	foundTargets []alpm.IPackage
+}
+
+func (h *AllSyncHandler) Test(target Target) bool {
+	if pkg := h.db.SyncSatisfier(target.Name); pkg != nil {
+		h.foundTargets = append(h.foundTargets, pkg)
+		return true
+	}
+
+	return false
+}
+
+func (h *AllSyncHandler) Graph(ctx context.Context, graph *topo.Graph[string, *InstallInfo]) error {
+	for _, pkg := range h.foundTargets {
+		GraphSyncPkg(ctx, h.db, graph, h.log, pkg, nil)
+	}
+	return nil
+}
+
+type SyncHandler struct {
+	log         *text.Logger
+	db          db.Executor
+	foundPkgs   []alpm.IPackage
+	foundGroups []Target
+}
+
+func (h *SyncHandler) Test(target Target) bool {
+	pkg, err := h.db.SatisfierFromDB(target.Name, target.DB)
+	if err != nil {
+		h.log.Warnln("Unable to search DB", err)
+		return false
+	}
+
+	if pkg != nil {
+		h.foundPkgs = append(h.foundPkgs, pkg)
+		return true
+	}
+
+	groupPackages, err := h.db.PackagesFromGroupAndDB(target.Name, target.DB)
+	if err != nil {
+		h.log.Warnln("Unable to search DB", err)
+		return false
+	}
+
+	if len(groupPackages) > 0 {
+		h.foundGroups = append(h.foundGroups, Target{DB: target.DB, Name: target.Name})
+		return true
+	}
+
+	return false
+}
+
+func (h *SyncHandler) Graph(ctx context.Context, graph *topo.Graph[string, *InstallInfo]) error {
+	for _, pkg := range h.foundPkgs {
+		GraphSyncPkg(ctx, h.db, graph, h.log, pkg, nil)
+	}
+
+	for _, target := range h.foundGroups {
+		GraphSyncGroup(ctx, graph, target.Name, target.DB)
+	}
+	return nil
+}
+
+type AllSyncGroupHandler struct {
+	db           db.Executor
+	foundTargets []Target
+}
+
+func (h *AllSyncGroupHandler) Test(target Target) bool {
+	groupPackages := h.db.PackagesFromGroup(target.Name)
+	if len(groupPackages) > 0 {
+		dbName := groupPackages[0].DB().Name()
+		h.foundTargets = append(h.foundTargets, Target{DB: dbName, Name: target.Name})
+		return true
+	}
+
+	return false
+}
+
+func (h *AllSyncGroupHandler) Graph(ctx context.Context, graph *topo.Graph[string, *InstallInfo]) error {
+	for _, target := range h.foundTargets {
+		GraphSyncGroup(ctx, graph, target.Name, target.DB)
+	}
+	return nil
+}
+
+func GraphSyncPkg(ctx context.Context, dbExecutor db.Executor,
+	graph *topo.Graph[string, *InstallInfo], logger *text.Logger,
+	pkg alpm.IPackage, upgradeInfo *db.SyncUpgrade,
+) *topo.Graph[string, *InstallInfo] {
+	if graph == nil {
+		graph = NewGraph()
+	}
+
+	graph.AddNode(pkg.Name())
+	_ = pkg.Provides().ForEach(func(p *alpm.Depend) error {
+		logger.Debugln(pkg.Name() + " provides: " + p.String())
+		graph.Provides(p.Name, p, pkg.Name())
+		return nil
+	})
+
+	dbName := pkg.DB().Name()
+	info := &InstallInfo{
+		Source:     Sync,
+		Reason:     Explicit,
+		Version:    pkg.Version(),
+		SyncDBName: &dbName,
+	}
+
+	if upgradeInfo == nil {
+		if localPkg := dbExecutor.LocalPackage(pkg.Name()); localPkg != nil {
+			info.Reason = Reason(localPkg.Reason())
+		}
+	} else {
+		info.Upgrade = true
+		info.Reason = Reason(upgradeInfo.Reason)
+		info.LocalVersion = upgradeInfo.LocalVersion
+	}
+
+	validateAndSetNodeInfo(graph, pkg.Name(), &topo.NodeInfo[*InstallInfo]{
+		Color:      colorMap[info.Reason],
+		Background: bgColorMap[info.Source],
+		Value:      info,
+	})
+
+	return graph
+}
+
+func GraphSyncGroup(ctx context.Context,
+	graph *topo.Graph[string, *InstallInfo],
+	groupName, dbName string,
+) *topo.Graph[string, *InstallInfo] {
+	if graph == nil {
+		graph = NewGraph()
+	}
+
+	graph.AddNode(groupName)
+
+	validateAndSetNodeInfo(graph, groupName, &topo.NodeInfo[*InstallInfo]{
+		Color:      colorMap[Explicit],
+		Background: bgColorMap[Sync],
+		Value: &InstallInfo{
+			Source:     Sync,
+			Reason:     Explicit,
+			Version:    "",
+			SyncDBName: &dbName,
+			IsGroup:    true,
+		},
+	})
+
+	return graph
+}