Add uninstall

Uninstall can be done in different ways - the most accurate would be to try find a minimum subset of packages that gives conflicts and try to reduce them gradually.
E.g. this could be done with other SAT algorithms. For now we keep things simple and we compute the uninstalls as an indirect of an installation from an empty profile.

Also take care of corner cases where world has no clauses, and fixes a typo in building the world formula

pkg/package/package.go

@@ -33,9 +33,12 @@ type Package interface {
 	BuildFormula() ([]bf.Formula, error)
 	IsFlagged(bool) Package
 	Flagged() bool
-
+	GetFingerPrint() string
 	Requires([]*DefaultPackage) Package
 	Conflicts([]*DefaultPackage) Package
+
+	GetRequires() []*DefaultPackage
+	GetConflicts() []*DefaultPackage
 }
 
 type DefaultPackage struct {
@@ -54,6 +57,9 @@ type State string
 func NewPackage(name, version string, requires []*DefaultPackage, conflicts []*DefaultPackage) *DefaultPackage {
 	return &DefaultPackage{Name: name, Version: version, PackageRequires: requires, PackageConflicts: conflicts}
 }
+func (p *DefaultPackage) GetFingerPrint() string {
+	return p.Name
+}
 
 func (p *DefaultPackage) AddUse(use string) {
 	for _, v := range p.UseFlags {
@@ -102,7 +108,12 @@ func (p *DefaultPackage) SetState(state State) Package {
 	p.State = state
 	return p
 }
-
+func (p *DefaultPackage) GetRequires() []*DefaultPackage {
+	return p.PackageRequires
+}
+func (p *DefaultPackage) GetConflicts() []*DefaultPackage {
+	return p.PackageConflicts
+}
 func (p *DefaultPackage) Requires(req []*DefaultPackage) Package {
 	p.PackageRequires = req
 	return p

pkg/solver/solver.go

@@ -27,6 +27,7 @@ type State interface{ Encode() string }
 type PackageSolver interface {
 	SetWorld(p []pkg.Package)
 	Install(p []pkg.Package) ([]PackageAssert, error)
+	Uninstall(candidate pkg.Package) ([]pkg.Package, error)
 }
 type Solver struct {
 	Wanted    []pkg.Package
@@ -48,21 +49,60 @@ func (s *Solver) SetWorld(p []pkg.Package) {
 	s.World = p
 }
 
+func (s *Solver) noRulesWorld() bool {
+	for _, p := range s.World {
+		if len(p.GetConflicts()) != 0 || len(p.GetRequires()) != 0 {
+			return false
+		}
+	}
+
+	return true
+}
+
 func (s *Solver) BuildWorld() (bf.Formula, error) {
 	var formulas []bf.Formula
+	// for _, p := range s.Installed {
+	// 	solvable, err := p.BuildFormula()
+	// 	if err != nil {
+	// 		return nil, err
+	// 	}
+	// 	//f = bf.And(f, solvable)
+	// 	formulas = append(formulas, solvable...)
 
-	for _, p := range s.Wanted {
+	// }
+	for _, p := range s.World {
 		solvable, err := p.BuildFormula()
 		if err != nil {
 			return nil, err
 		}
-		//f = bf.And(f, solvable)
 		formulas = append(formulas, solvable...)
-
 	}
 	return bf.And(formulas...), nil
 }
 
+// world is ok with Px (installed-x-th) and removal of package (candidate?)
+// collect unsatisfieds and repeat until we get no more unsatisfieds
+func (s *Solver) Uninstall(candidate pkg.Package) ([]pkg.Package, error) {
+	var res []pkg.Package
+	saved := s.Installed
+	s.Installed = []pkg.Package{}
+
+	asserts, err := s.Install([]pkg.Package{candidate})
+	if err != nil {
+		return nil, err
+	}
+	s.Installed = saved
+
+	for _, a := range asserts {
+		if a.Value && a.Package.Flagged() {
+			res = append(res, a.Package.IsFlagged(false))
+		}
+
+	}
+
+	return res, nil
+}
+
 func (s *Solver) BuildFormula() (bf.Formula, error) {
 	//f := bf.True
 	var formulas []bf.Formula
@@ -70,17 +110,18 @@ func (s *Solver) BuildFormula() (bf.Formula, error) {
 	if err != nil {
 		return nil, err
 	}
-	formulas = append(formulas, r)
 	for _, wanted := range s.Wanted {
 		encodedW, err := wanted.IsFlagged(true).Encode()
 		if err != nil {
 			return nil, err
 		}
 		W := bf.Var(encodedW)
+
 		if len(s.Installed) == 0 {
-			formulas = append(formulas, bf.And(bf.True, W))
+			formulas = append(formulas, W) //bf.And(bf.True, W))
 			continue
 		}
+
 		for _, installed := range s.Installed {
 			encodedI, err := installed.IsFlagged(true).Encode()
 			if err != nil {
@@ -91,6 +132,8 @@ func (s *Solver) BuildFormula() (bf.Formula, error) {
 		}
 
 	}
+	formulas = append(formulas, r)
+
 	return bf.And(formulas...), nil
 }
 
@@ -125,5 +168,17 @@ func (s *Solver) Install(coll []pkg.Package) ([]PackageAssert, error) {
 	}
 	s.Wanted = coll
 
+	if s.noRulesWorld() {
+		var ass []PackageAssert
+		for _, p := range s.Installed {
+			ass = append(ass, PackageAssert{Package: p.IsFlagged(true), Value: true})
+
+		}
+		for _, p := range s.Wanted {
+			ass = append(ass, PackageAssert{Package: p.IsFlagged(true), Value: true})
+		}
+		return ass, nil
+	}
+
 	return s.Solve()
 }

pkg/solver/solver_test.go

@@ -26,13 +26,72 @@ import (
 var _ = Describe("Solver", func() {
 
 	Context("Simple set", func() {
+		It("Solves correctly if the selected package has no requirements or conflicts and we have nothing installed yet", func() {
+			B := pkg.NewPackage("B", "", []*pkg.DefaultPackage{}, []*pkg.DefaultPackage{})
+			A := pkg.NewPackage("A", "", []*pkg.DefaultPackage{}, []*pkg.DefaultPackage{})
+			C := pkg.NewPackage("C", "", []*pkg.DefaultPackage{}, []*pkg.DefaultPackage{})
+
+			s := NewSolver([]pkg.Package{}, []pkg.Package{A, B, C})
+			solution, err := s.Install([]pkg.Package{A})
+			Expect(err).ToNot(HaveOccurred())
+			Expect(solution).To(ContainElement(PackageAssert{Package: A.IsFlagged(true), Value: true}))
+			Expect(len(solution)).To(Equal(1))
+		})
+
+		It("Solves correctly if the selected package has no requirements or conflicts and we have installed one package", func() {
+			B := pkg.NewPackage("B", "", []*pkg.DefaultPackage{}, []*pkg.DefaultPackage{})
+			A := pkg.NewPackage("A", "", []*pkg.DefaultPackage{}, []*pkg.DefaultPackage{})
+			C := pkg.NewPackage("C", "", []*pkg.DefaultPackage{}, []*pkg.DefaultPackage{})
+
+			s := NewSolver([]pkg.Package{C}, []pkg.Package{A, B, C})
+			solution, err := s.Install([]pkg.Package{B})
+			Expect(err).ToNot(HaveOccurred())
+			Expect(solution).To(ContainElement(PackageAssert{Package: B.IsFlagged(true), Value: true}))
+			Expect(solution).To(ContainElement(PackageAssert{Package: C.IsFlagged(true), Value: true}))
+			Expect(len(solution)).To(Equal(2))
+		})
+
+		It("Solves correctly if the selected package to install has no requirement or conflicts, but in the world there is one with a requirement", func() {
+			B := pkg.NewPackage("B", "", []*pkg.DefaultPackage{}, []*pkg.DefaultPackage{})
+			A := pkg.NewPackage("A", "", []*pkg.DefaultPackage{}, []*pkg.DefaultPackage{})
+			C := pkg.NewPackage("C", "", []*pkg.DefaultPackage{}, []*pkg.DefaultPackage{})
+			D := pkg.NewPackage("D", "", []*pkg.DefaultPackage{B}, []*pkg.DefaultPackage{})
+			E := pkg.NewPackage("E", "", []*pkg.DefaultPackage{}, []*pkg.DefaultPackage{})
+
+			s := NewSolver([]pkg.Package{E, C}, []pkg.Package{A, B, C, D, E})
+			solution, err := s.Install([]pkg.Package{A})
+			Expect(err).ToNot(HaveOccurred())
+			Expect(solution).To(ContainElement(PackageAssert{Package: A.IsFlagged(true), Value: true}))
+			Expect(solution).To(ContainElement(PackageAssert{Package: C.IsFlagged(true), Value: true}))
+			Expect(solution).To(ContainElement(PackageAssert{Package: E.IsFlagged(true), Value: true}))
+			Expect(solution).To(ContainElement(PackageAssert{Package: B.IsFlagged(true), Value: false}))
+			Expect(solution).To(ContainElement(PackageAssert{Package: D.IsFlagged(true), Value: false}))
+
+			Expect(len(solution)).To(Equal(5))
+		})
+
+		It("Solves correctly if the selected package to install has requirements", func() {
+			B := pkg.NewPackage("B", "", []*pkg.DefaultPackage{}, []*pkg.DefaultPackage{})
+			C := pkg.NewPackage("C", "", []*pkg.DefaultPackage{}, []*pkg.DefaultPackage{})
+			D := pkg.NewPackage("D", "", []*pkg.DefaultPackage{}, []*pkg.DefaultPackage{})
+			A := pkg.NewPackage("A", "", []*pkg.DefaultPackage{D}, []*pkg.DefaultPackage{})
+
+			s := NewSolver([]pkg.Package{C}, []pkg.Package{A, B, C, D})
+			solution, err := s.Install([]pkg.Package{A})
+			Expect(err).ToNot(HaveOccurred())
+			Expect(solution).To(ContainElement(PackageAssert{Package: A.IsFlagged(true), Value: true}))
+			Expect(solution).To(ContainElement(PackageAssert{Package: C.IsFlagged(true), Value: true}))
+			Expect(solution).To(ContainElement(PackageAssert{Package: D.IsFlagged(true), Value: true}))
+
+			Expect(len(solution)).To(Equal(3))
+		})
 
 		It("Solves correctly", func() {
 			B := pkg.NewPackage("B", "", []*pkg.DefaultPackage{}, []*pkg.DefaultPackage{})
 			A := pkg.NewPackage("A", "", []*pkg.DefaultPackage{B}, []*pkg.DefaultPackage{})
 			C := pkg.NewPackage("C", "", []*pkg.DefaultPackage{}, []*pkg.DefaultPackage{})
 
-			s := NewSolver([]pkg.Package{C}, []pkg.Package{A, B, C}) // XXX: goes fatal with odd numbers of cnf ?
+			s := NewSolver([]pkg.Package{C}, []pkg.Package{A, B, C})
 			solution, err := s.Install([]pkg.Package{A})
 			Expect(err).ToNot(HaveOccurred())
 			Expect(solution).To(ContainElement(PackageAssert{Package: A.IsFlagged(true), Value: true}))
@@ -45,7 +104,6 @@ var _ = Describe("Solver", func() {
 			D := pkg.NewPackage("D", "", []*pkg.DefaultPackage{}, []*pkg.DefaultPackage{})
 			B := pkg.NewPackage("B", "", []*pkg.DefaultPackage{D}, []*pkg.DefaultPackage{})
 			A := pkg.NewPackage("A", "", []*pkg.DefaultPackage{B}, []*pkg.DefaultPackage{})
-			C.IsFlagged(true) // installed
 
 			s := NewSolver([]pkg.Package{C}, []pkg.Package{A, B, C, D})
 
@@ -59,14 +117,13 @@ var _ = Describe("Solver", func() {
 		})
 
 		It("Solves correctly more complex ones", func() {
-			//	E := pkg.NewPackage("E", "", []*pkg.DefaultPackage{}, []*pkg.DefaultPackage{})
-
+			E := pkg.NewPackage("E", "", []*pkg.DefaultPackage{}, []*pkg.DefaultPackage{})
 			C := pkg.NewPackage("C", "", []*pkg.DefaultPackage{}, []*pkg.DefaultPackage{})
 			D := pkg.NewPackage("D", "", []*pkg.DefaultPackage{}, []*pkg.DefaultPackage{})
 			B := pkg.NewPackage("B", "", []*pkg.DefaultPackage{D}, []*pkg.DefaultPackage{})
 			A := pkg.NewPackage("A", "", []*pkg.DefaultPackage{B}, []*pkg.DefaultPackage{})
 
-			s := NewSolver([]pkg.Package{}, []pkg.Package{A, B, C, D})
+			s := NewSolver([]pkg.Package{}, []pkg.Package{A, B, C, D, E})
 
 			solution, err := s.Install([]pkg.Package{A})
 			Expect(solution).To(ContainElement(PackageAssert{Package: A.IsFlagged(true), Value: true}))
@@ -76,6 +133,44 @@ var _ = Describe("Solver", func() {
 			Expect(err).ToNot(HaveOccurred())
 		})
 
+		It("Uninstalls simple package correctly", func() {
+			C := pkg.NewPackage("C", "", []*pkg.DefaultPackage{}, []*pkg.DefaultPackage{})
+			D := pkg.NewPackage("D", "", []*pkg.DefaultPackage{}, []*pkg.DefaultPackage{})
+			B := pkg.NewPackage("B", "", []*pkg.DefaultPackage{}, []*pkg.DefaultPackage{})
+			A := pkg.NewPackage("A", "", []*pkg.DefaultPackage{}, []*pkg.DefaultPackage{})
+
+			s := NewSolver([]pkg.Package{A, B, C, D}, []pkg.Package{A, B, C, D})
+
+			solution, err := s.Uninstall(A)
+			Expect(err).ToNot(HaveOccurred())
+
+			Expect(solution).To(ContainElement(A.IsFlagged(false)))
+
+			//	Expect(solution).To(ContainElement(PackageAssert{Package: C.IsFlagged(true), Value: true}))
+			Expect(len(solution)).To(Equal(1))
+		})
+
+		It("Uninstalls complex package correctly", func() {
+			C := pkg.NewPackage("C", "", []*pkg.DefaultPackage{}, []*pkg.DefaultPackage{})
+			D := pkg.NewPackage("D", "", []*pkg.DefaultPackage{}, []*pkg.DefaultPackage{})
+			B := pkg.NewPackage("B", "", []*pkg.DefaultPackage{D}, []*pkg.DefaultPackage{})
+			A := pkg.NewPackage("A", "", []*pkg.DefaultPackage{B}, []*pkg.DefaultPackage{})
+			C.IsFlagged(true) // installed
+
+			s := NewSolver([]pkg.Package{A, B, C, D}, []pkg.Package{A, B, C, D})
+
+			solution, err := s.Uninstall(A)
+			Expect(solution).To(ContainElement(A.IsFlagged(false)))
+			Expect(solution).To(ContainElement(B.IsFlagged(false)))
+			//Expect(solution).To(ContainElement(C.IsFlagged(true)))
+			Expect(solution).To(ContainElement(D.IsFlagged(false)))
+
+			//	Expect(solution).To(ContainElement(PackageAssert{Package: C.IsFlagged(true), Value: true}))
+			Expect(len(solution)).To(Equal(3))
+			Expect(err).ToNot(HaveOccurred())
+
+		})
+
 	})
 
 	Context("Conflict set", func() {