system/yay
system/yay
1
0
Fork 0
mirror of https://github.com/Jguer/yay synced 2024-07-21 10:16:10 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

add dep graph for local install

Browse source
This commit is contained in:
jguer 2022-09-06 23:38:47 +02:00
parent f7286b25ae
commit cadeecc4df
No known key found for this signature in database
GPG key ID: 6D6CC9BEA8556B35
4 changed files with 87 additions and 142 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

16
install.go
View file

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

134
local_install.go
View file

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

15
pkg/db/types.go Normal file
View file

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

64
pkg/dep/depGraph.go
View file

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