Move selection logic to a db accessor #19

In this way the compiler consume such accessor, and make it possible to expand whenever used

pkg/compiler/compiler.go

@@ -482,7 +482,7 @@ func (cs *LuetCompiler) compile(concurrency int, keepPermissions bool, p Compila
 
 func (cs *LuetCompiler) FromPackage(p pkg.Package) (CompilationSpec, error) {
 
-	pack, err := cs.Database.FindPackage(p)
+	pack, err := cs.Database.FindPackageCandidate(p)
 	if err != nil {
 		return nil, err
 	}

pkg/package/database.go

@@ -42,6 +42,8 @@ type PackageSet interface {
 	RemovePackageFiles(Package) error
 
 	World() []Package
+
+	FindPackageCandidate(p Package) (Package, error)
 }
 
 type PackageFile struct {

pkg/package/database_boltdb.go

@@ -276,3 +276,25 @@ func (db *BoltDatabase) World() []Package {
 	}
 	return all
 }
+
+func (db *BoltDatabase) FindPackageCandidate(p Package) (Package, error) {
+
+	required, err := db.FindPackage(p)
+	if err != nil {
+		w := db.World()
+		//	return nil, errors.Wrap(err, "Couldn't find required package in db definition")
+		packages, err := p.Expand(&w)
+		//	Info("Expanded", packages, err)
+		if err != nil || len(packages) == 0 {
+			required = p
+		} else {
+			required = Best(packages)
+
+		}
+		return required, nil
+		//required = &DefaultPackage{Name: "test"}
+	}
+
+	return required, err
+
+}

pkg/package/database_mem.go

@@ -263,3 +263,25 @@ func (db *InMemoryDatabase) World() []Package {
 	}
 	return all
 }
+
+func (db *InMemoryDatabase) FindPackageCandidate(p Package) (Package, error) {
+
+	required, err := db.FindPackage(p)
+	if err != nil {
+		w := db.World()
+		//	return nil, errors.Wrap(err, "Couldn't find required package in db definition")
+		packages, err := p.Expand(&w)
+		//	Info("Expanded", packages, err)
+		if err != nil || len(packages) == 0 {
+			required = p
+		} else {
+			required = Best(packages)
+
+		}
+		return required, nil
+		//required = &DefaultPackage{Name: "test"}
+	}
+
+	return required, err
+
+}

pkg/package/package.go

@@ -27,6 +27,7 @@ import (
 	"github.com/crillab/gophersat/bf"
 	version "github.com/hashicorp/go-version"
 	"github.com/jinzhu/copier"
+	"github.com/pkg/errors"
 
 	"github.com/ghodss/yaml"
 )
@@ -368,18 +369,9 @@ func (pack *DefaultPackage) BuildFormula(definitiondb PackageDatabase, db Packag
 	var formulas []bf.Formula
 	w := definitiondb.World() // FIXME: this is heavy
 	for _, requiredDef := range p.GetRequires() {
-		required, err := definitiondb.FindPackage(requiredDef)
+		required, err := definitiondb.FindPackageCandidate(requiredDef)
 		if err != nil {
-			//	return nil, errors.Wrap(err, "Couldn't find required package in db definition")
-			packages, err := requiredDef.Expand(&w)
-			//	Info("Expanded", packages, err)
-			if err != nil || len(packages) == 0 {
-				required = requiredDef
-			} else {
-				required = Best(packages)
-
-			}
-			//required = &DefaultPackage{Name: "test"}
+			return nil, errors.Wrap(err, "Couldn't find required package in db definition")
 		}
 
 		encodedB, err := required.Encode(db)

pkg/solver/decoder.go

@@ -145,25 +145,15 @@ func (assertions PackagesAssertions) Order(definitiondb pkg.PackageDatabase, fin
 	}
 
 	sort.Sort(unorderedAssertions)
-	w := definitiondb.World() // FIXME: this is heavy
 
 	// Build a topological graph
 	//graph := toposort.NewGraph(len(unorderedAssertions))
 	//	graph.AddNodes(fingerprints...)
 	for _, a := range unorderedAssertions {
 		for _, requiredDef := range a.Package.GetRequires() {
-			req, err := definitiondb.FindPackage(requiredDef)
+			req, err := definitiondb.FindPackageCandidate(requiredDef)
 			if err != nil {
-				//	return nil, errors.Wrap(err, "Couldn't find required package in db definition")
-				packages, err := requiredDef.Expand(&w)
-				//	Info("Expanded", packages, err)
-				if err != nil || len(packages) == 0 {
 				req = requiredDef
-				} else {
-					req = pkg.Best(packages)
-
-				}
-				//required = &DefaultPackage{Name: "test"}
 			}
 
 			// Expand also here, as we need to order them (or instead the solver should give back the dep correctly?)