wip

Author: tangrufus

and.go

@@ -4,7 +4,7 @@ import "slices"
 
 const (
 	ErrNotEnoughEndless   stringError = "not enough endless"
-	ErrUnpextedAnd        stringError = "unexpected and"
+	ErrUnexpectedAndLogic stringError = "unexpected and logic"
 	ErrImpossibleInterval stringError = "impossible interval"
 )
 
@@ -36,7 +36,7 @@ func And(es ...Endless) (CeilingFloorConstrainter, error) {
 	if !floorOk && !ceilingOk {
 		var c CeilingFloorConstrainter
 		// logic error! This should never happen.
-		return c, ErrUnpextedAnd
+		return c, ErrUnexpectedAndLogic
 	}
 
 	if floorOk && !ceilingOk {

constraint.go

@@ -1,22 +1,65 @@
 package comver
 
+import "slices"
+
 type Constrainter interface {
 	Check(v Version) bool
+	String() string
 }
 
 type CeilingFloorConstrainter interface {
+	Constrainter
 	ceilinger
 	floorer
-	Constrainter
 }
 
-func overlap(a, b CeilingFloorConstrainter) bool {
+func wildcard(c CeilingFloorConstrainter) bool {
+	return c.Floor().wildcard() && c.Ceiling().wildcard()
+}
+
+// TODO: test me.
+func minCeilinglessFloor(cs ...CeilingFloorConstrainter) (CeilingFloorConstrainter, bool) {
+	cs = slices.Clone(cs)
+
+	cs = slices.DeleteFunc(cs, func(c CeilingFloorConstrainter) bool {
+		return !c.Ceiling().wildcard()
+	})
+
+	if len(cs) == 0 {
+		var c CeilingFloorConstrainter
+		return c, false
+	}
+
+	return slices.MinFunc(cs, func(a, b CeilingFloorConstrainter) int {
+		return a.Floor().compare(b.Floor())
+	}), true
+}
+
+// TODO: test me.
+func maxFloorlessCeiling(cs ...CeilingFloorConstrainter) (CeilingFloorConstrainter, bool) {
+	cs = slices.Clone(cs)
+
+	cs = slices.DeleteFunc(cs, func(c CeilingFloorConstrainter) bool {
+		return !c.Floor().wildcard()
+	})
+
+	if len(cs) == 0 {
+		var c CeilingFloorConstrainter
+		return c, false
+	}
+
+	return slices.MaxFunc(cs, func(a, b CeilingFloorConstrainter) int {
+		return a.Ceiling().compare(b.Ceiling())
+	}), true
+}
+
+func overlap(a, b CeilingFloorConstrainter) bool { // TODO: Test me.
 	// TODO: Assume version != nil?
 	return a.Check(*b.Floor().version) ||
 		b.Check(*a.Floor().version)
 }
 
-func seamless(a, b CeilingFloorConstrainter) bool {
+func seamless(a, b CeilingFloorConstrainter) bool { // TODO: Test me.
 	// TODO: Assume version != nil?
 
 	fn := func(a, b CeilingFloorConstrainter) bool {

interval.go

@@ -21,13 +21,5 @@ func (i interval) Floor() Endless {
 }
 
 func (i interval) String() string {
-	if i.ceiling.wildcard() {
-		return i.floor.String()
-	}
-
-	if i.floor.wildcard() {
-		return i.ceiling.String()
-	}
-
 	return i.Floor().String() + " " + i.Ceiling().String()
 }

or.go

@@ -1,85 +1,111 @@
 package comver
 
-type Or []CeilingFloorConstrainter
+import (
+	"slices"
+)
+
+// Or represents a logical OR operation between multiple [CeilingFloorConstrainter] instances.
+// The zero value of Or is a constraint could never be satisfied.
+type Or []CeilingFloorConstrainter //nolint:godox // TODO: Use Constrainter so that we can nest Or.
 
 func (o Or) Check(v Version) bool {
-	return true // TODO: Implement!
+	for i := range o {
+		if o[i].Check(v) {
+			return true
+		}
+	}
+	return false
 }
 
-//func CompactOr(cs Or) Constrainter {
-//	if len(cs) == 0 {
-//		return NewWildcard()
-//	}
-//	if len(cs) == 1 {
-//		return cs[0]
-//	}
-//
-//	cs = slices.Clone(cs)
-//
-//	// if there cs a wildcard, return only the wildcard
-//	w := slices.ContainsFunc(cs, func(c CeilingFloorConstrainter) bool {
-//		return c.Floor().version == nil && c.Ceiling().version == nil
-//	})
-//	if w {
-//		return NewWildcard()
-//	}
-//
-//	head, headOk := minBoundedFloor(cs...)
-//	cs = slices.DeleteFunc(cs, func(c CeilingFloorConstrainter) bool {
-//		return c.Floor().version == nil
-//	})
-//	if headOk {
-//		cs = append(cs, head)
-//	}
-//
-//	tail, tailOk := maxBoundedCelling(cs)
-//	cs = slices.DeleteFunc(cs, func(c CeilingFloorConstrainter) bool {
-//		return c.Ceiling().version == nil
-//	})
-//	if tailOk {
-//		cs = append(cs, tail)
-//	}
-//
-//	// TODO: Check whether interval{head, tail} are wildcard.
-//	// If yes, early return wildcard
-//
-//	// important!
-//	slices.SortFunc(cs, compareSimpleConstrainters)
-//
-//	// remove duplicates
-//	cs = slices.CompactFunc(cs, func(a, b CeilingFloorConstrainter) bool {
-//		return compareSimpleConstrainters(a, b) == 0
-//	})
-//
-//	vals := make(Or, 0, len(cs))
-//	pendingI := cs[0]
-//	for index := range cs {
-//		i, ok := compactTwoSCs(pendingI, cs[index])
-//		if ok {
-//			pendingI = i
-//		} else {
-//			vals = append(vals, pendingI)
-//			pendingI = cs[index]
-//		}
-//
-//		if index == len(cs)-1 {
-//			vals = append(vals, pendingI)
-//		}
-//	}
-//
-//	return slices.Clip(vals)
-//}
-
-func compactTwoSCs(a, b CeilingFloorConstrainter) (CeilingFloorConstrainter, bool) {
-	cmp := compareSimpleConstrainters(a, b)
-	if cmp > 0 {
-		a, b = b, a
+func (o Or) String() string { // TODO: Test me.
+	s := ""
+	for i := range o {
+		if i > 0 {
+			s += " || "
+		}
+		s += o[i].String()
 	}
+	return s
+}
 
+// Compact returns a new [Constrainter] that is logically equivalent to the input o.
+// The returned [Constrainter] may or may be not be an [Or] instance.
+// When it is, Compact tries to return the shortest [Or] possible.
+func Compact(o Or) Constrainter { // TODO: Test me.
+	if len(o) == 0 {
+		return o
+	}
+	if len(o) == 1 {
+		return o[0]
+	}
+
+	o = slices.Clone(o)
+
+	// wildcard trumps everything else.
+	if slices.ContainsFunc(o, wildcard) {
+		return NewWildcard()
+	}
+
+	ceiling, ceilingOk := maxFloorlessCeiling(o...)
+	floor, floorOk := minCeilinglessFloor(o...)
+
+	if ceilingOk && floorOk {
+		if formWildcard(ceiling.Ceiling(), floor.Floor()) {
+			return NewWildcard()
+		}
+	}
+
+	o = slices.DeleteFunc(o, func(c CeilingFloorConstrainter) bool {
+		return c.Ceiling().wildcard() || c.Floor().wildcard()
+	})
+
+	// important to sort before compacting
+	slices.SortFunc(o, compareCeilingFloorConstrainters)
+	// remove duplicates
+	o = slices.CompactFunc(o, func(a, b CeilingFloorConstrainter) bool {
+		return compareCeilingFloorConstrainters(a, b) == 0
+	})
+
+	vals := make(Or, 0, len(o)+2)
+	pendingI := o[0]
+	for index := range o {
+		i, ok := compactTwo(pendingI, o[index])
+		if ok {
+			pendingI = i
+		} else {
+			vals = append(vals, pendingI)
+			pendingI = o[index]
+		}
+
+		if index == len(o)-1 {
+			vals = append(vals, pendingI)
+		}
+	}
+
+	var head Or
+	if floorOk {
+		head = append(head, floor)
+	}
+	var tail Or
+	if ceilingOk {
+		tail = append(tail, ceiling)
+	}
+
+	r := slices.Concat(head, vals, tail)
+	return slices.Clip(r)
+}
+
+// TODO: Test me.
+func compactTwo(a, b CeilingFloorConstrainter) (CeilingFloorConstrainter, bool) {
+	cmp := compareCeilingFloorConstrainters(a, b)
 	if cmp == 0 {
 		return a, true
 	}
 
+	if cmp > 0 {
+		a, b = b, a
+	}
+
 	if !overlap(a, b) && !seamless(a, b) {
 		return a, false
 	}
@@ -91,10 +117,51 @@ func compactTwoSCs(a, b CeilingFloorConstrainter) (CeilingFloorConstrainter, boo
 	return interval{a.Floor(), b.Ceiling()}, true
 }
 
-func compareSimpleConstrainters(a, b CeilingFloorConstrainter) int {
+// TODO: Test me.
+func compareCeilingFloorConstrainters(a, b CeilingFloorConstrainter) int {
 	cmp := a.Floor().compare(b.Floor())
 	if cmp != 0 {
 		return cmp
 	}
 	return a.Ceiling().compare(b.Ceiling())
 }
+
+// TODO: Test me.
+func formWildcard(e, f Endless) bool {
+	if e.wildcard() {
+		return true
+	}
+
+	if f.wildcard() {
+		return true
+	}
+
+	if e.op.ceilingBounded() && f.op.ceilingBounded() {
+		return false
+	}
+
+	if e.op.floorBounded() && f.op.floorBounded() {
+		return false
+	}
+
+	cmp := e.compare(f)
+
+	if cmp == 0 {
+		return false
+	}
+
+	if cmp > 0 {
+		e, f = f, e
+	}
+
+	vCmp := e.version.Compare(*f.version)
+	if vCmp == 0 {
+		return e.inclusive() || f.inclusive()
+	}
+
+	if e.op.ceilingBounded() || f.op.floorBounded() {
+		return false
+	}
+
+	return false
+}