kairos/luet
1
0
Fork 0
mirror of https://github.com/mudler/luet.git synced 2025-08-11 04:02:08 +00:00
Code Issues Packages Projects Releases Wiki Activity

Normalize input data beforeahead

Browse Source
This commit is contained in:
Ettore Di Giacinto 2019-06-05 18:40:33 +02:00
parent 6e7cef4710
commit 86472e7bf5
No known key found for this signature in database
GPG Key ID: F557248F4D256736
3 changed files with 44 additions and 6 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

16
pkg/package/package.go
View File

@ -147,18 +147,30 @@ func DecodePackage(ID string) (Package, error) {
return p, nil return p, nil
} }
func NormalizeFlagged(p Package) {
for _, r := range p.GetRequires() {
r.IsFlagged(true)
NormalizeFlagged(r)
}
for _, r := range p.GetConflicts() {
r.IsFlagged(true)
NormalizeFlagged(r)
}
}
func (p *DefaultPackage) BuildFormula() ([]bf.Formula, error) { func (p *DefaultPackage) BuildFormula() ([]bf.Formula, error) {
encodedA, err := p.IsFlagged(true).Encode() encodedA, err := p.IsFlagged(true).Encode()
if err != nil { if err != nil {
return nil, err return nil, err
} }
NormalizeFlagged(p)
A := bf.Var(encodedA) A := bf.Var(encodedA)
var formulas []bf.Formula var formulas []bf.Formula
for _, required := range p.PackageRequires { for _, required := range p.PackageRequires {
encodedB, err := required.IsFlagged(true).Encode() encodedB, err := required.Encode()
if err != nil { if err != nil {
return nil, err return nil, err
} }
@ -174,7 +186,7 @@ func (p *DefaultPackage) BuildFormula() ([]bf.Formula, error) {
} }
for _, required := range p.PackageConflicts { for _, required := range p.PackageConflicts {
encodedB, err := required.IsFlagged(true).Encode() encodedB, err := required.Encode()
if err != nil { if err != nil {
return nil, err return nil, err
} }

8
pkg/solver/solver.go
View File

@ -37,10 +37,10 @@ type Solver struct {
func NewSolver(init []pkg.Package, w []pkg.Package) PackageSolver { func NewSolver(init []pkg.Package, w []pkg.Package) PackageSolver {
for _, v := range init { for _, v := range init {
v.IsFlagged(true) pkg.NormalizeFlagged(v)
} }
for _, v := range w { for _, v := range w {
v.IsFlagged(true) pkg.NormalizeFlagged(v)
} }
return &Solver{Installed: init, World: w} return &Solver{Installed: init, World: w}
} }
@ -111,7 +111,7 @@ func (s *Solver) BuildFormula() (bf.Formula, error) {
return nil, err return nil, err
} }
for _, wanted := range s.Wanted { for _, wanted := range s.Wanted {
encodedW, err := wanted.IsFlagged(true).Encode() encodedW, err := wanted.Encode()
if err != nil { if err != nil {
return nil, err return nil, err
} }
@ -123,7 +123,7 @@ func (s *Solver) BuildFormula() (bf.Formula, error) {
} }
for _, installed := range s.Installed { for _, installed := range s.Installed {
encodedI, err := installed.IsFlagged(true).Encode() encodedI, err := installed.Encode()
if err != nil { if err != nil {
return nil, err return nil, err
} }

26
pkg/solver/solver_test.go
View File

@ -190,4 +190,30 @@ var _ = Describe("Solver", func() {
}) })
Context("Complex data sets", func() {
It("Solves them correctly", func() {
C := pkg.NewPackage("C", "", []*pkg.DefaultPackage{}, []*pkg.DefaultPackage{})
E := pkg.NewPackage("E", "", []*pkg.DefaultPackage{}, []*pkg.DefaultPackage{})
F := pkg.NewPackage("F", "", []*pkg.DefaultPackage{}, []*pkg.DefaultPackage{})
G := pkg.NewPackage("G", "", []*pkg.DefaultPackage{}, []*pkg.DefaultPackage{})
H := pkg.NewPackage("H", "", []*pkg.DefaultPackage{G}, []*pkg.DefaultPackage{})
D := pkg.NewPackage("D", "", []*pkg.DefaultPackage{H}, []*pkg.DefaultPackage{})
B := pkg.NewPackage("B", "", []*pkg.DefaultPackage{D}, []*pkg.DefaultPackage{})
A := pkg.NewPackage("A", "", []*pkg.DefaultPackage{B}, []*pkg.DefaultPackage{})
s := NewSolver([]pkg.Package{C}, []pkg.Package{A, B, C, D, E, F, G})
solution, err := s.Install([]pkg.Package{A})
Expect(solution).To(ContainElement(PackageAssert{Package: A.IsFlagged(true), Value: true}))
Expect(solution).To(ContainElement(PackageAssert{Package: B.IsFlagged(true), Value: true}))
Expect(solution).To(ContainElement(PackageAssert{Package: D.IsFlagged(true), Value: true}))
Expect(solution).To(ContainElement(PackageAssert{Package: C.IsFlagged(true), Value: true}))
Expect(solution).To(ContainElement(PackageAssert{Package: H.IsFlagged(true), Value: true}))
Expect(solution).To(ContainElement(PackageAssert{Package: G.IsFlagged(true), Value: true}))
Expect(len(solution)).To(Equal(6))
Expect(err).ToNot(HaveOccurred())
})
})
}) })