Revert "Do not allow multiple versions in the results"

This reverts commit 15534ce253.

pkg/installer/installer_test.go

@@ -294,9 +294,6 @@ uri: "`+tmpdir+`"
 			_, errs := c.CompileParallel(2, false, compiler.NewLuetCompilationspecs(spec, spec2, spec3))
 
 			Expect(errs).To(BeEmpty())
-			//	_, errs = c.CompileParallel(2, false, compiler.NewLuetCompilationspecs(spec2))
-
-			//	Expect(errs).To(BeEmpty())
 
 			repo, err := GenerateRepository("test", tmpdir, "local", 1, tmpdir, "../../tests/fixtures/upgrade", pkg.NewInMemoryDatabase(false))
 			Expect(err).ToNot(HaveOccurred())

pkg/package/package.go

@@ -401,9 +401,6 @@ func (pack *DefaultPackage) BuildFormula(definitiondb PackageDatabase, db Packag
 
 	var formulas []bf.Formula
 	for _, requiredDef := range p.GetRequires() {
-		// TODO: Change, instead of selecting best, we should enforce a rule
-		// between all the versions of that package (there must be only one),
-		// and selection of one of those versions to match a requirement
 		required, err := definitiondb.FindPackageCandidate(requiredDef)
 		if err != nil {
 			return nil, errors.Wrap(err, "Couldn't find required package in db definition")

pkg/solver/decoder.go

@@ -19,7 +19,6 @@ import (
 	"crypto/sha256"
 	"fmt"
 	"sort"
-	"strings"
 	"unicode"
 
 	pkg "github.com/mudler/luet/pkg/package"
@@ -54,23 +53,7 @@ func DecodeModel(model map[string]bool, db pkg.PackageDatabase) (PackagesAsserti
 		}
 		ass = append(ass, PackageAssert{Package: a.(*pkg.DefaultPackage), Value: v})
 	}
-
-	results := make(PackagesAssertions, 0)
-
-	// FIXME: This should go away when BuildFormula() in Packages will take into account different versions in range
-	// That is, it needs to select one of the versions in a requirment range ( >= 0.1 ) that mets the constraints
-	for _, a := range ass {
-		if !results.Contains(a.Package) {
-			results = append(results, a)
-			continue
-		}
-		if results.ContainsBigger(a.Package) {
-			//swap
-			results = results.DropPackageName(a.Package)
-			results = append(results, a)
-		}
-	}
-	return results, nil
+	return ass, nil
 }
 
 func (a *PackageAssert) Explain() {
@@ -92,37 +75,6 @@ func (a *PackageAssert) ToString() string {
 	return fmt.Sprintf("%s/%s %s %s", a.Package.GetCategory(), a.Package.GetName(), a.Package.GetVersion(), msg)
 }
 
-func (assertions PackagesAssertions) Contains(p pkg.Package) bool {
-	for _, a := range assertions {
-		if a.Package.GetPackageName() == p.GetPackageName() && a.Value == true {
-			return true
-		}
-	}
-
-	return false
-}
-
-func (assertions PackagesAssertions) Search(f string) *PackageAssert {
-	for _, a := range assertions {
-		if strings.Contains(a.Package.GetFingerPrint(), f) {
-			return &a
-		}
-	}
-
-	return nil
-}
-
-func (assertions PackagesAssertions) ContainsBigger(p pkg.Package) bool {
-	for _, a := range assertions {
-		if a.Package.GetPackageName() == p.GetPackageName() && a.Value == true && a.Package.Bigger(p) {
-
-			return true
-		}
-	}
-
-	return false
-}
-
 func (assertions PackagesAssertions) EnsureOrder() PackagesAssertions {
 
 	orderedAssertions := PackagesAssertions{}
@@ -175,16 +127,13 @@ func (assertions PackagesAssertions) Order(definitiondb pkg.PackageDatabase, fin
 	orderedAssertions := PackagesAssertions{}
 	unorderedAssertions := PackagesAssertions{}
 	fingerprints := []string{}
-	tmpMap := map[string]PackageAssert{}
 
+	tmpMap := map[string]PackageAssert{}
 	graph := topsort.NewGraph()
-	assertionDb := pkg.NewInMemoryDatabase(false)
 
 	for _, a := range assertions {
 		graph.AddNode(a.Package.GetFingerPrint())
-		assertionDb.CreatePackage(a.Package)
 		tmpMap[a.Package.GetFingerPrint()] = a
-
 		fingerprints = append(fingerprints, a.Package.GetFingerPrint())
 		unorderedAssertions = append(unorderedAssertions, a) // Build a list of the ones that must be ordered
 
@@ -202,14 +151,13 @@ func (assertions PackagesAssertions) Order(definitiondb pkg.PackageDatabase, fin
 	//	graph.AddNodes(fingerprints...)
 	for _, a := range unorderedAssertions {
 		for _, requiredDef := range a.Package.GetRequires() {
-			req := assertions.Search(requiredDef.GetPackageName())
+			req, err := definitiondb.FindPackageCandidate(requiredDef)
+			if err != nil {
+				req = requiredDef
+			}
 
-			//	if req == nil {
-			//		req = requiredDef
-			//	}
 			// Expand also here, as we need to order them (or instead the solver should give back the dep correctly?)
-
-			graph.AddEdge(a.Package.GetFingerPrint(), req.Package.GetFingerPrint())
+			graph.AddEdge(a.Package.GetFingerPrint(), req.GetFingerPrint())
 		}
 	}
 	result, err := graph.TopSort(fingerprint)
@@ -217,17 +165,12 @@ func (assertions PackagesAssertions) Order(definitiondb pkg.PackageDatabase, fin
 		panic(err)
 	}
 	for _, res := range result {
-		a := assertions.Search(res)
-		if a == nil {
-			ass, ok := tmpMap[res]
-			if !ok {
-				//panic("fail")
-				continue
-			}
-			a = &ass
+		a, ok := tmpMap[res]
+		if !ok {
+			panic("fail")
+			//	continue
 		}
-
-		orderedAssertions = append(orderedAssertions, *a)
+		orderedAssertions = append(orderedAssertions, a)
 		//	orderedAssertions = append(PackagesAssertions{a}, orderedAssertions...) // push upfront
 	}
 	//helpers.ReverseAny(orderedAssertions)
@@ -296,14 +239,3 @@ func (assertions PackagesAssertions) Drop(p pkg.Package) PackagesAssertions {
 	}
 	return ass
 }
-
-func (assertions PackagesAssertions) DropPackageName(p pkg.Package) PackagesAssertions {
-	ass := PackagesAssertions{}
-
-	for _, a := range assertions {
-		if a.Package.GetPackageName() != p.GetPackageName() {
-			ass = append(ass, a)
-		}
-	}
-	return ass
-}

pkg/solver/solver_test.go

@@ -326,37 +326,6 @@ var _ = Describe("Solver", func() {
 			Expect(len(solution)).To(Equal(3))
 			Expect(err).ToNot(HaveOccurred())
 		})
-
-		It("Selects one version", func() {
-
-			E := pkg.NewPackage("E", "", []*pkg.DefaultPackage{}, []*pkg.DefaultPackage{})
-			C := pkg.NewPackage("C", "", []*pkg.DefaultPackage{}, []*pkg.DefaultPackage{})
-			D2 := pkg.NewPackage("D", "1.9", []*pkg.DefaultPackage{}, []*pkg.DefaultPackage{})
-			D := pkg.NewPackage("D", "1.8", []*pkg.DefaultPackage{}, []*pkg.DefaultPackage{})
-			D1 := pkg.NewPackage("D", "1.4", []*pkg.DefaultPackage{}, []*pkg.DefaultPackage{})
-			B := pkg.NewPackage("B", "1.1", []*pkg.DefaultPackage{&pkg.DefaultPackage{Name: "D", Version: "1.4"}}, []*pkg.DefaultPackage{})
-			A := pkg.NewPackage("A", "", []*pkg.DefaultPackage{&pkg.DefaultPackage{Name: "D", Version: ">=1.0"}}, []*pkg.DefaultPackage{})
-
-			for _, p := range []pkg.Package{A, B, C, D, D1, D2, E} {
-				_, err := dbDefinitions.CreatePackage(p)
-				Expect(err).ToNot(HaveOccurred())
-			}
-
-			for _, p := range []pkg.Package{} {
-				_, err := dbInstalled.CreatePackage(p)
-				Expect(err).ToNot(HaveOccurred())
-			}
-			s = NewSolver(dbInstalled, dbDefinitions, db)
-
-			solution, err := s.Install([]pkg.Package{A, B})
-			Expect(solution).To(ContainElement(PackageAssert{Package: A, Value: true}))
-			Expect(solution).To(ContainElement(PackageAssert{Package: B, Value: true}))
-			Expect(solution).To(ContainElement(PackageAssert{Package: D1, Value: true}))
-			Expect(solution).ToNot(ContainElement(PackageAssert{Package: D, Value: true}))
-
-			Expect(len(solution)).To(Equal(3))
-			Expect(err).ToNot(HaveOccurred())
-		})
 		It("Uninstalls simple package correctly", func() {
 
 			C := pkg.NewPackage("C", "", []*pkg.DefaultPackage{}, []*pkg.DefaultPackage{})

pkg/tree/recipes_test.go

@@ -120,7 +120,7 @@ var _ = Describe("Recipe", func() {
 				s := solver.NewSolver(pkg.NewInMemoryDatabase(false), tree, tree)
 				solution, err := s.Install([]pkg.Package{pack})
 				Expect(err).ToNot(HaveOccurred())
-				//		Expect(len(solution)).To(Equal(8))
+				Expect(len(solution)).To(Equal(10))
 
 				var allSol string
 				for _, sol := range solution {
@@ -128,7 +128,7 @@ var _ = Describe("Recipe", func() {
 				}
 
 				Expect(allSol).To(ContainSubstring("app-crypt/pinentry-base 1.0.0 installed"))
-				Expect(allSol).ToNot(ContainSubstring("app-crypt/pinentry 1.1.0-r2 installed"))
+				Expect(allSol).To(ContainSubstring("app-crypt/pinentry 1.1.0-r2 not installed"))
 				Expect(allSol).To(ContainSubstring("app-crypt/pinentry 1.0.0-r2 installed"))
 			})
 		})