Switch all LURE operations to use new DB

build.go

@@ -44,6 +44,7 @@ import (
 	"go.arsenm.dev/lure/download"
 	"go.arsenm.dev/lure/internal/config"
 	"go.arsenm.dev/lure/internal/cpu"
+	"go.arsenm.dev/lure/internal/repos"
 	"go.arsenm.dev/lure/internal/shutils"
 	"go.arsenm.dev/lure/internal/shutils/decoder"
 	"go.arsenm.dev/lure/manager"
@@ -220,15 +221,25 @@ func buildPackage(ctx context.Context, script string, mgr manager.Manager) ([]st
 	}
 
 	if len(buildDeps) > 0 {
+		found, notFound, err := repos.FindPkgs(gdb, buildDeps)
+		if err != nil {
+			return nil, nil, err
+		}
+
 		log.Info("Installing build dependencies").Send()
-		installPkgs(ctx, buildDeps, mgr, false)
+		installPkgs(ctx, flattenFoundPkgs(found), notFound, mgr)
 	}
 
 	var builtDeps, builtNames, repoDeps []string
 	if len(vars.Depends) > 0 {
 		log.Info("Installing dependencies").Send()
 
-		scripts, notFound := findPkgs(vars.Depends)
+		found, notFound, err := repos.FindPkgs(gdb, vars.Depends)
+		if err != nil {
+			return nil, nil, err
+		}
+
+		scripts := getScriptPaths(flattenFoundPkgs(found))
 		for _, script := range scripts {
 			pkgPaths, pkgNames, err := buildPackage(ctx, script, mgr)
 			if err != nil {

info.go

@@ -19,11 +19,13 @@
 package main
 
 import (
-	"go.arsenm.dev/logger/log"
+	"fmt"
 	"os"
 
+	"go.arsenm.dev/logger/log"
+
 	"github.com/urfave/cli/v2"
-	"go.arsenm.dev/lure/distro"
+	"go.arsenm.dev/lure/internal/repos"
 	"gopkg.in/yaml.v3"
 )
 
@@ -33,27 +35,23 @@ func infoCmd(c *cli.Context) error {
 		log.Fatalf("Command info expected at least 1 argument, got %d", args.Len()).Send()
 	}
 
-	info, err := distro.ParseOSRelease(c.Context)
+	found, _, err := repos.FindPkgs(gdb, args.Slice())
 	if err != nil {
-		log.Fatal("Error parsing os-release").Err(err).Send()
+		log.Fatal("Error finding packages").Err(err).Send()
 	}
 
-	found, err := findPkg(args.First())
+	if len(found) == 0 {
-	if err != nil {
+		os.Exit(1)
-		log.Fatal("Error finding package").Err(err).Send()
 	}
 
-	// if multiple are matched, only use the first one
+	pkgs := flattenFoundPkgs(found)
-	script := found[0]
 
-	vars, err := getBuildVars(c.Context, script, info)
+	for _, pkg := range pkgs {
-	if err != nil {
+		err = yaml.NewEncoder(os.Stdout).Encode(pkg)
-		log.Fatal("Error getting build variables").Err(err).Send()
+		if err != nil {
-	}
+			log.Fatal("Error encoding script variables").Err(err).Send()
-
+		}
-	err = yaml.NewEncoder(os.Stdout).Encode(vars)
+		fmt.Println("---")
-	if err != nil {
-		log.Fatal("Error encoding script variables").Err(err).Send()
 	}
 
 	return nil

install.go

@@ -20,10 +20,13 @@ package main
 
 import (
 	"context"
+	"path/filepath"
 
 	"go.arsenm.dev/logger/log"
 
 	"github.com/urfave/cli/v2"
+	"go.arsenm.dev/lure/internal/config"
+	"go.arsenm.dev/lure/internal/db"
 	"go.arsenm.dev/lure/internal/repos"
 	"go.arsenm.dev/lure/manager"
 )
@@ -39,21 +42,21 @@ func installCmd(c *cli.Context) error {
 		log.Fatal("Unable to detect supported package manager on system").Send()
 	}
 
-	installPkgs(c.Context, args.Slice(), mgr, true)
+	err := repos.Pull(c.Context, gdb, cfg.Repos)
+	if err != nil {
+		log.Fatal("Error pulling repositories").Err(err).Send()
+	}
 
+	found, notFound, err := repos.FindPkgs(gdb, args.Slice())
+	if err != nil {
+		log.Fatal("Error finding packages").Err(err).Send()
+	}
+
+	installPkgs(c.Context, flattenFoundPkgs(found), notFound, mgr)
 	return nil
 }
 
-func installPkgs(ctx context.Context, pkgs []string, mgr manager.Manager, pull bool) {
+func installPkgs(ctx context.Context, pkgs []db.Package, notFound []string, mgr manager.Manager) {
-	if pull {
-		err := repos.Pull(ctx, gdb, cfg.Repos)
-		if err != nil {
-			log.Fatal("Error pulling repositories").Err(err).Send()
-		}
-	}
-
-	scripts, notFound := findPkgs(pkgs)
-
 	if len(notFound) > 0 {
 		err := mgr.Install(nil, notFound...)
 		if err != nil {
@@ -61,7 +64,32 @@ func installPkgs(ctx context.Context, pkgs []string, mgr manager.Manager, pull b
 		}
 	}
 
-	installScripts(ctx, mgr, scripts)
+	installScripts(ctx, mgr, getScriptPaths(pkgs))
+}
+
+func getScriptPaths(pkgs []db.Package) []string {
+	var scripts []string
+	for _, pkg := range pkgs {
+		scriptPath := filepath.Join(config.RepoDir, pkg.Repository, pkg.Name, "lure.sh")
+		scripts = append(scripts, scriptPath)
+	}
+	return scripts
+}
+
+func flattenFoundPkgs(found map[string][]db.Package) []db.Package {
+	var outPkgs []db.Package
+	for _, pkgs := range found {
+		if len(pkgs) > 1 {
+			choices, err := pkgPrompt(pkgs)
+			if err != nil {
+				log.Fatal("Error prompting for choice of package").Send()
+			}
+			outPkgs = append(outPkgs, choices...)
+		} else if len(pkgs) == 1 {
+			outPkgs = append(outPkgs, pkgs[0])
+		}
+	}
+	return outPkgs
 }
 
 func installScripts(ctx context.Context, mgr manager.Manager, scripts []string) {

internal/repos/find.go

@@ -7,13 +7,14 @@ import (
 	"go.arsenm.dev/lure/internal/db"
 )
 
-func FindPkgs(gdb *genji.DB, pkgs []string) (map[string][]db.Package, error) {
+func FindPkgs(gdb *genji.DB, pkgs []string) (map[string][]db.Package, []string, error) {
 	found := map[string][]db.Package{}
+	notFound := []string(nil)
 
 	for _, pkgName := range pkgs {
 		result, err := db.GetPkgs(gdb, "name LIKE ?", pkgName)
 		if err != nil {
-			return nil, err
+			return nil, nil, err
 		}
 
 		added := 0
@@ -30,13 +31,13 @@ func FindPkgs(gdb *genji.DB, pkgs []string) (map[string][]db.Package, error) {
 		})
 		result.Close()
 		if err != nil {
-			return nil, err
+			return nil, nil, err
 		}
 
 		if added == 0 {
 			result, err := db.GetPkgs(gdb, "? IN provides", pkgName)
 			if err != nil {
-				return nil, err
+				return nil, nil, err
 			}
 
 			err = result.Iterate(func(d types.Document) error {
@@ -52,10 +53,14 @@ func FindPkgs(gdb *genji.DB, pkgs []string) (map[string][]db.Package, error) {
 			})
 			result.Close()
 			if err != nil {
-				return nil, err
+				return nil, nil, err
 			}
 		}
+
+		if added == 0 {
+			notFound = append(notFound, pkgName)
+		}
 	}
 
-	return found, nil
+	return found, notFound, nil
 }

list.go

@@ -21,29 +21,32 @@ package main
 import (
 	"fmt"
 
+	"github.com/genjidb/genji/document"
+	"github.com/genjidb/genji/types"
 	"github.com/urfave/cli/v2"
 	"go.arsenm.dev/logger/log"
-	"go.arsenm.dev/lure/distro"
+	"go.arsenm.dev/lure/internal/db"
 )
 
 func listCmd(c *cli.Context) error {
-	info, err := distro.ParseOSRelease(c.Context)
+	result, err := db.GetPkgs(gdb, "true")
 	if err != nil {
-		log.Fatal("Error parsing os-release").Err(err).Send()
+		log.Fatal("Error getting packages").Err(err).Send()
 	}
+	defer result.Close()
 
-	pkgs, err := findPkg("*")
+	err = result.Iterate(func(d types.Document) error {
-	if err != nil {
+		var pkg db.Package
-		log.Fatal("Error finding packages").Err(err).Send()
+		err := document.StructScan(d, &pkg)
-	}
-
-	for _, script := range pkgs {
-		vars, err := getBuildVars(c.Context, script, info)
 		if err != nil {
-			log.Fatal("Error getting build variables").Err(err).Send()
+			return err
 		}
 
-		fmt.Println(vars.Name, vars.Version)
+		fmt.Printf("%s/%s %s\n", pkg.Repository, pkg.Name, pkg.Version)
+		return nil
+	})
+	if err != nil {
+		log.Fatal("Error iterating over packages").Err(err).Send()
 	}
 
 	return nil

repo.go

@@ -27,6 +27,7 @@ import (
 	"github.com/urfave/cli/v2"
 	"go.arsenm.dev/logger/log"
 	"go.arsenm.dev/lure/internal/config"
+	"go.arsenm.dev/lure/internal/db"
 	"go.arsenm.dev/lure/internal/repos"
 	"go.arsenm.dev/lure/internal/types"
 	"golang.org/x/exp/slices"
@@ -111,41 +112,10 @@ func refreshCmd(c *cli.Context) error {
 	return nil
 }
 
-func findPkg(pkg string) ([]string, error) {
+func pkgPrompt(options []db.Package) ([]db.Package, error) {
-	var out []string
-	for _, repo := range cfg.Repos {
-		repoDir := filepath.Join(config.RepoDir, repo.Name)
-		err := os.MkdirAll(repoDir, 0o755)
-		if err != nil {
-			return nil, err
-		}
-
-		glob := filepath.Join(repoDir, pkg, "lure.sh")
-		matches, err := filepath.Glob(glob)
-		if err != nil {
-			return nil, err
-		}
-
-		if len(matches) == 0 {
-			continue
-		}
-
-		out = append(out, matches...)
-	}
-
-	if len(out) == 0 {
-		return nil, PkgNotFoundError{pkgName: pkg}
-	}
-
-	return out, nil
-}
-
-func pkgPrompt(options []string) ([]string, error) {
 	names := make([]string, len(options))
 	for i, option := range options {
-		pkgDir := filepath.Dir(option)
+		names[i] = option.Repository + "/" + option.Name + " " + option.Version
-		repoDir := filepath.Dir(pkgDir)
-		names[i] = filepath.Base(repoDir) + "/" + filepath.Base(pkgDir)
 	}
 
 	prompt := &survey.MultiSelect{
@@ -159,32 +129,10 @@ func pkgPrompt(options []string) ([]string, error) {
 		return nil, err
 	}
 
-	out := make([]string, len(choices))
+	out := make([]db.Package, len(choices))
 	for i, choiceIndex := range choices {
 		out[i] = options[choiceIndex]
 	}
 
 	return out, nil
 }
-
-func findPkgs(pkgs []string) (scripts, notFound []string) {
-	for _, pkg := range pkgs {
-		found, err := findPkg(pkg)
-		if _, ok := err.(PkgNotFoundError); ok {
-			notFound = append(notFound, pkg)
-			continue
-		}
-
-		if len(found) == 1 {
-			scripts = append(scripts, found...)
-		} else {
-			choices, err := pkgPrompt(found)
-			if err != nil {
-				log.Fatal("Error prompting for package choices").Err(err).Send()
-			}
-
-			scripts = append(scripts, choices...)
-		}
-	}
-	return
-}

upgrade.go

@@ -25,9 +25,12 @@ import (
 	"github.com/urfave/cli/v2"
 	"go.arsenm.dev/logger/log"
 	"go.arsenm.dev/lure/distro"
+	"go.arsenm.dev/lure/internal/db"
 	"go.arsenm.dev/lure/internal/repos"
 	"go.arsenm.dev/lure/manager"
 	"go.arsenm.dev/lure/vercmp"
+	"golang.org/x/exp/maps"
+	"golang.org/x/exp/slices"
 )
 
 func upgradeCmd(c *cli.Context) error {
@@ -52,7 +55,7 @@ func upgradeCmd(c *cli.Context) error {
 	}
 
 	if len(updates) > 0 {
-		installPkgs(c.Context, updates, mgr, false)
+		installPkgs(c.Context, updates, nil, mgr)
 	} else {
 		log.Info("There is nothing to do.").Send()
 	}
@@ -60,41 +63,43 @@ func upgradeCmd(c *cli.Context) error {
 	return nil
 }
 
-func checkForUpdates(ctx context.Context, mgr manager.Manager, info *distro.OSRelease) ([]string, error) {
+func checkForUpdates(ctx context.Context, mgr manager.Manager, info *distro.OSRelease) ([]db.Package, error) {
 	installed, err := mgr.ListInstalled(nil)
 	if err != nil {
 		return nil, err
 	}
 
-	var out []string
+	pkgNames := maps.Keys(installed)
-	for name, version := range installed {
+	found, _, err := repos.FindPkgs(gdb, pkgNames)
-		scripts, err := findPkg(name)
+	if err != nil {
-		if err != nil {
+		return nil, err
-			continue
+	}
+
+	var out []db.Package
+	for pkgName, pkgs := range found {
+		if len(pkgs) > 1 {
+			// Puts the element with the highest version first
+			slices.SortFunc(pkgs, func(a, b db.Package) bool {
+				return vercmp.Compare(a.Version, b.Version) == 1
+			})
 		}
 
-		// since we're not using a glob, we can assume a single item
+		// First element is the package we want to install
-		script := scripts[0]
+		pkg := pkgs[0]
 
-		vars, err := getBuildVars(ctx, script, info)
+		repoVer := pkg.Version
-		if err != nil {
+		if pkg.Release != 0 && pkg.Epoch == 0 {
-			log.Fatal("Error getting build variables").Err(err).Send()
+			repoVer = fmt.Sprintf("%s-%d", pkg.Version, pkg.Release)
+		} else if pkg.Release != 0 && pkg.Epoch != 0 {
+			repoVer = fmt.Sprintf("%d:%s-%d", pkg.Epoch, pkg.Version, pkg.Release)
 		}
 
-		repoVer := vars.Version
+		c := vercmp.Compare(repoVer, installed[pkgName])
-		if vars.Release != 0 && vars.Epoch == 0 {
-			repoVer = fmt.Sprintf("%s-%d", vars.Version, vars.Release)
-		} else if vars.Release != 0 && vars.Epoch != 0 {
-			repoVer = fmt.Sprintf("%d:%s-%d", vars.Epoch, vars.Version, vars.Release)
-		}
-
-		c := vercmp.Compare(repoVer, version)
 		if c == 0 || c == -1 {
 			continue
 		} else if c == 1 {
-			out = append(out, name)
+			out = append(out, pkg)
 		}
 	}
-
 	return out, nil
 }