Adapt package.Best to take a Versioner interface

pkg/package/database_boltdb.go

@@ -338,7 +338,7 @@ func (db *BoltDatabase) FindPackageCandidate(p Package) (Package, error) {
 		if err != nil || len(packages) == 0 {
 			required = p
 		} else {
-			required = packages.Best()
+			required = packages.Best(nil)
 
 		}
 		return required, nil

pkg/package/database_mem.go

@@ -349,7 +349,7 @@ func (db *InMemoryDatabase) FindPackageCandidate(p Package) (Package, error) {
 		if err != nil || len(packages) == 0 {
 			required = p
 		} else {
-			required = packages.Best()
+			required = packages.Best(nil)
 
 		}
 		return required, nil

pkg/package/package.go

@@ -23,15 +23,14 @@ import (
 	"io"
 	"path/filepath"
 	"regexp"
-	"sort"
 	"strconv"
 	"strings"
 
 	gentoo "github.com/Sabayon/pkgs-checker/pkg/gentoo"
 	"github.com/crillab/gophersat/bf"
 	"github.com/ghodss/yaml"
-	version "github.com/hashicorp/go-version"
 	"github.com/jinzhu/copier"
+	version "github.com/mudler/luet/pkg/versioner"
 	"github.com/pkg/errors"
 )
 
@@ -460,7 +459,13 @@ func (pack *DefaultPackage) RequiresContains(definitiondb PackageDatabase, s Pac
 	return false, nil
 }
 
-func (set Packages) Best() Package {
+// Best returns the best version of the package (the most bigger) from a list
+// Accepts a versioner interface to change the ordering policy. If null is supplied
+// It defaults to version.WrappedVersioner which supports both semver and debian versioning
+func (set Packages) Best(v version.Versioner) Package {
+	if v == nil {
+		v = &version.WrappedVersioner{}
+	}
 	var versionsMap map[string]Package = make(map[string]Package)
 	if len(set) == 0 {
 		panic("Best needs a list with elements")
@@ -468,22 +473,12 @@ func (set Packages) Best() Package {
 
 	versionsRaw := []string{}
 	for _, p := range set {
-		// TODO: This is temporary!.
+		versionsRaw = append(versionsRaw, p.GetVersion())
-		sanitizedVersion := strings.ReplaceAll(p.GetVersion(), "_", "-")
+		versionsMap[p.GetVersion()] = p
-		versionsRaw = append(versionsRaw, sanitizedVersion)
-		versionsMap[sanitizedVersion] = p
 	}
+	sorted := v.Sort(versionsRaw)
 
-	versions := make([]*version.Version, len(versionsRaw))
+	return versionsMap[sorted[len(sorted)-1]]
-	for i, raw := range versionsRaw {
-		v, _ := version.NewVersion(raw)
-		versions[i] = v
-	}
-
-	// After this, the versions are properly sorted
-	sort.Sort(version.Collection(versions))
-
-	return versionsMap[versions[len(versions)-1].Original()]
 }
 
 func (pack *DefaultPackage) BuildFormula(definitiondb PackageDatabase, db PackageDatabase) ([]bf.Formula, error) {

pkg/package/package_test.go

@@ -58,7 +58,7 @@ var _ = Describe("Package", func() {
 			Expect(lst).To(ContainElement(a1))
 			Expect(lst).ToNot(ContainElement(a01))
 			Expect(len(lst)).To(Equal(2))
-			p := lst.Best()
+			p := lst.Best(nil)
 			Expect(p).To(Equal(a11))
 		})
 	})

pkg/solver/solver.go

@@ -141,7 +141,7 @@ func (s *Solver) getList(db pkg.PackageDatabase, lsp pkg.Packages) (pkg.Packages
 			if err != nil || len(packages) == 0 {
 				cp = pp
 			} else {
-				cp = packages.Best()
+				cp = packages.Best(nil)
 			}
 		}
 		ls = append(ls, cp)
@@ -229,7 +229,7 @@ func (s *Solver) Upgrade(checkconflicts bool) (pkg.Packages, PackagesAssertions,
 		installedcopy.CreatePackage(p)
 		packages, ok := availableCache[p.GetName()+p.GetCategory()]
 		if ok && len(packages) != 0 {
-			best := packages.Best()
+			best := packages.Best(nil)
 			if best.GetVersion() != p.GetVersion() {
 				toUninstall = append(toUninstall, p)
 				toInstall = append(toInstall, best)
@@ -272,7 +272,7 @@ func (s *Solver) Uninstall(c pkg.Package, checkconflicts bool) (pkg.Packages, er
 		if err != nil || len(packages) == 0 {
 			candidate = c
 		} else {
-			candidate = packages.Best()
+			candidate = packages.Best(nil)
 		}
 		//Relax search, otherwise we cannot compute solutions for packages not in definitions
 		//	return nil, errors.Wrap(err, "Package not found between installed")

pkg/solver/solver_test.go

@@ -882,7 +882,7 @@ var _ = Describe("Solver", func() {
 			Expect(lst).To(ContainElement(a03))
 			Expect(lst).ToNot(ContainElement(old))
 			Expect(len(lst)).To(Equal(5))
-			p := lst.Best()
+			p := lst.Best(nil)
 			Expect(p).To(Equal(a03))
 		})
 	})