Add PEP 440 version comparison for pypi scheme (#26)

* Add PEP 440 version comparison for pypi scheme

parseDotSeparated silently dropped non-numeric segment suffixes, so
5.2b1 parsed as 5.0.0 and every PEP 440 prerelease form collapsed to
the release. There was also no pypi case in CompareWithScheme, and
Range.Contains used generic comparison regardless of scheme.

Add a PEP 440 comparator covering epoch, release padding, pre/post/dev
ordering, spelling and separator normalization, and local version
segments. Store the scheme on Range so Contains can dispatch to it.
Split trailing letter suffixes in parseDotSeparated instead of
discarding them.

Fixes #24

* Address review findings on PEP 440 comparison

Range.IsEmpty used generic comparison, so a pypi range like
[1.0.dev1, 1.0a1) reported empty and serialized as vers:pypi/.
Use the scheme comparator there too.

Scheme was not set on ranges from the wildcard path, ParseNative
sub-parsers that bypass parseConstraints (including pypi ~=), or
the results of Union/Intersect/Exclude. Stamp it in each of those
places so Contains and IsEmpty on the result use the right rules.

Replace the 1<<30 positive-infinity sentinel in the PEP 440
comparator with explicit hasPre/hasPost/hasDev flags. Numeric
components are unbounded in PEP 440 and a large enough dev number
sorted the wrong side of an absent one.

* Thread scheme comparator through interval algebra; compare PEP 440 numerics as strings

Range.Intersect and Range.Union built results using generic
comparison, so intersecting >=1.0.dev1 with <1.0a1 under pypi
discarded the resulting interval as empty. Add cmp-taking variants
of Interval.Intersect/Union/Overlaps/Adjacent and mergeIntervals,
and have Range.Intersect/Union use the scheme comparator.

Store PEP 440 numeric components (epoch, release segments, pre/post/
dev numbers, numeric local segments) as digit strings and compare
them by length then lexically. Values that overflow int no longer
collapse to zero, and large local segments stay numeric.

* Derive pypi ~= upper bound from PEP 440 release segments; use scheme equality for Union exclusions

parsePypiRange delegated ~= to the gem pessimistic algorithm, which
counts raw dots (so .dev/.post added phantom segments) and drops the
epoch. ~=1.4.dev1 produced <1.5 instead of <2, and ~=1!1.4.5 lost the
epoch on the upper bound. Add a pypi-specific handler that reads the
release segments and epoch via parsePEP440 and increments the
second-last release segment. Stop trimming trailing zeros from the
parsed release so ~=2.0.dev1 sees two segments; cmpNumStrSlice already
treats missing segments as zero so comparison is unchanged.

Range.Union intersected exclusions by string equality, so unioning
ranges that exclude 1.5 and 1.5.0 respectively dropped the exclusion
even though those are the same version under PEP 440. Compare with
the scheme comparator instead.

* Parse comma-separated pypi specifiers individually and intersect

parsePypiRange checked for a leading ~= before splitting on comma,
so ~=1.4.2,!=1.4.5 fed the whole tail into the compatible-release
handler and lost the exclusion. The comma path also rewrote parts to
pipe-separated constraints, which never re-entered ~= handling, so
>=1.0,~=1.4 treated ~=1.4 as an exact version and left the range
unbounded above.

Split on comma first, parse each part on its own (so ~= is handled
per part), and Range.Intersect the results. Comma is AND in PEP 440.

* Set pypi scheme on ~= result before intersection

parsePypiCompatibleRelease returned a Range with an empty Scheme,
relying on the ParseNative wrapper to stamp it afterwards. When ~=
was the first clause in a comma-separated set, the subsequent
Intersect ran under generic comparison and discarded intervals like
[1.0.dev1, 1.0a1) as empty. Set the scheme on the ~= result (and its
fallback) so intersection order does not matter.

Author: andrew

interval.go

@@ -48,12 +48,16 @@ func LessThanInterval(version string, inclusive bool) Interval {
 
 // IsEmpty returns true if this interval matches no versions.
 func (i Interval) IsEmpty() bool {
+	return i.isEmptyCmp(CompareVersions)
+}
+
+func (i Interval) isEmptyCmp(cmp func(a, b string) int) bool {
 	if i.Min != "" && i.Max != "" {
-		cmp := CompareVersions(i.Min, i.Max)
-		if cmp > 0 {
+		c := cmp(i.Min, i.Max)
+		if c > 0 {
 			return true
 		}
-		if cmp == 0 && (!i.MinInclusive || !i.MaxInclusive) {
+		if c == 0 && (!i.MinInclusive || !i.MaxInclusive) {
 			return true
 		}
 	}
@@ -67,7 +71,11 @@ func (i Interval) IsUnbounded() bool {
 
 // Contains checks if the interval contains the given version.
 func (i Interval) Contains(version string) bool {
-	if i.IsEmpty() {
+	return i.containsCmp(version, CompareVersions)
+}
+
+func (i Interval) containsCmp(version string, cmp func(a, b string) int) bool {
+	if i.isEmptyCmp(cmp) {
 		return false
 	}
 	if i.IsUnbounded() {
@@ -76,27 +84,27 @@ func (i Interval) Contains(version string) bool {
 
 	// Check minimum bound
 	if i.Min != "" {
-		cmp := CompareVersions(version, i.Min)
+		c := cmp(version, i.Min)
 		if i.MinInclusive {
-			if cmp < 0 {
+			if c < 0 {
 				return false
 			}
 		} else {
-			if cmp <= 0 {
+			if c <= 0 {
 				return false
 			}
 		}
 	}
 
 	// Check maximum bound
 	if i.Max != "" {
-		cmp := CompareVersions(version, i.Max)
+		c := cmp(version, i.Max)
 		if i.MaxInclusive {
-			if cmp > 0 {
+			if c > 0 {
 				return false
 			}
 		} else {
-			if cmp >= 0 {
+			if c >= 0 {
 				return false
 			}
 		}
@@ -107,7 +115,11 @@ func (i Interval) Contains(version string) bool {
 
 // Intersect returns the intersection of two intervals.
 func (i Interval) Intersect(other Interval) Interval {
-	if i.IsEmpty() || other.IsEmpty() {
+	return i.intersectCmp(other, CompareVersions)
+}
+
+func (i Interval) intersectCmp(other Interval, cmp func(a, b string) int) Interval {
+	if i.isEmptyCmp(cmp) || other.isEmptyCmp(cmp) {
 		return EmptyInterval()
 	}
 
@@ -116,12 +128,12 @@ func (i Interval) Intersect(other Interval) Interval {
 	// Determine new minimum
 	switch {
 	case i.Min != "" && other.Min != "":
-		cmp := CompareVersions(i.Min, other.Min)
+		c := cmp(i.Min, other.Min)
 		switch {
-		case cmp > 0:
+		case c > 0:
 			result.Min = i.Min
 			result.MinInclusive = i.MinInclusive
-		case cmp < 0:
+		case c < 0:
 			result.Min = other.Min
 			result.MinInclusive = other.MinInclusive
 		default:
@@ -139,12 +151,12 @@ func (i Interval) Intersect(other Interval) Interval {
 	// Determine new maximum
 	switch {
 	case i.Max != "" && other.Max != "":
-		cmp := CompareVersions(i.Max, other.Max)
+		c := cmp(i.Max, other.Max)
 		switch {
-		case cmp < 0:
+		case c < 0:
 			result.Max = i.Max
 			result.MaxInclusive = i.MaxInclusive
-		case cmp > 0:
+		case c > 0:
 			result.Max = other.Max
 			result.MaxInclusive = other.MaxInclusive
 		default:
@@ -164,23 +176,31 @@ func (i Interval) Intersect(other Interval) Interval {
 
 // Overlaps returns true if the two intervals overlap.
 func (i Interval) Overlaps(other Interval) bool {
-	if i.IsEmpty() || other.IsEmpty() {
+	return i.overlapsCmp(other, CompareVersions)
+}
+
+func (i Interval) overlapsCmp(other Interval, cmp func(a, b string) int) bool {
+	if i.isEmptyCmp(cmp) || other.isEmptyCmp(cmp) {
 		return false
 	}
-	return !i.Intersect(other).IsEmpty()
+	return !i.intersectCmp(other, cmp).isEmptyCmp(cmp)
 }
 
 // Adjacent returns true if the two intervals are adjacent (can be merged).
 func (i Interval) Adjacent(other Interval) bool {
-	if i.IsEmpty() || other.IsEmpty() {
+	return i.adjacentCmp(other, CompareVersions)
+}
+
+func (i Interval) adjacentCmp(other Interval, cmp func(a, b string) int) bool {
+	if i.isEmptyCmp(cmp) || other.isEmptyCmp(cmp) {
 		return false
 	}
 
-	if i.Max != "" && other.Min != "" && CompareVersions(i.Max, other.Min) == 0 {
+	if i.Max != "" && other.Min != "" && cmp(i.Max, other.Min) == 0 {
 		return (i.MaxInclusive && !other.MinInclusive) || (!i.MaxInclusive && other.MinInclusive)
 	}
 
-	if i.Min != "" && other.Max != "" && CompareVersions(i.Min, other.Max) == 0 {
+	if i.Min != "" && other.Max != "" && cmp(i.Min, other.Max) == 0 {
 		return (i.MinInclusive && !other.MaxInclusive) || (!i.MinInclusive && other.MaxInclusive)
 	}
 
@@ -189,14 +209,18 @@ func (i Interval) Adjacent(other Interval) bool {
 
 // Union returns the union of two intervals, or nil if they cannot be merged.
 func (i Interval) Union(other Interval) *Interval {
-	if i.IsEmpty() {
+	return i.unionCmp(other, CompareVersions)
+}
+
+func (i Interval) unionCmp(other Interval, cmp func(a, b string) int) *Interval {
+	if i.isEmptyCmp(cmp) {
 		return &other
 	}
-	if other.IsEmpty() {
+	if other.isEmptyCmp(cmp) {
 		return &i
 	}
 
-	if !i.Overlaps(other) && !i.Adjacent(other) {
+	if !i.overlapsCmp(other, cmp) && !i.adjacentCmp(other, cmp) {
 		return nil
 	}
 
@@ -207,12 +231,12 @@ func (i Interval) Union(other Interval) *Interval {
 		result.Min = ""
 		result.MinInclusive = false
 	} else {
-		cmp := CompareVersions(i.Min, other.Min)
+		c := cmp(i.Min, other.Min)
 		switch {
-		case cmp < 0:
+		case c < 0:
 			result.Min = i.Min
 			result.MinInclusive = i.MinInclusive
-		case cmp > 0:
+		case c > 0:
 			result.Min = other.Min
 			result.MinInclusive = other.MinInclusive
 		default:
@@ -226,12 +250,12 @@ func (i Interval) Union(other Interval) *Interval {
 		result.Max = ""
 		result.MaxInclusive = false
 	} else {
-		cmp := CompareVersions(i.Max, other.Max)
+		c := cmp(i.Max, other.Max)
 		switch {
-		case cmp > 0:
+		case c > 0:
 			result.Max = i.Max
 			result.MaxInclusive = i.MaxInclusive
-		case cmp < 0:
+		case c < 0:
 			result.Max = other.Max
 			result.MaxInclusive = other.MaxInclusive
 		default:

parser.go

@@ -28,20 +28,30 @@ func (p *Parser) Parse(versURI string) (*Range, error) {
 
 	// Handle wildcard for unbounded range
 	if constraintsStr == "*" || constraintsStr == "" {
-		return Unbounded(), nil
+		r := Unbounded()
+		r.Scheme = scheme
+		return r, nil
 	}
 
 	return p.parseConstraints(constraintsStr, scheme)
 }
 
 // ParseNative parses a native package manager version range into a Range.
 func (p *Parser) ParseNative(constraint string, scheme string) (*Range, error) {
+	r, err := p.parseNative(constraint, scheme)
+	if r != nil && r.Scheme == "" {
+		r.Scheme = scheme
+	}
+	return r, err
+}
+
+func (p *Parser) parseNative(constraint string, scheme string) (*Range, error) {
 	switch scheme {
 	case "npm":
 		return p.parseNpmRange(constraint)
 	case "gem", "rubygems":
 		return p.parseGemRange(constraint)
-	case "pypi":
+	case "pypi": //nolint:goconst
 		return p.parsePypiRange(constraint)
 	case "maven":
 		return p.parseMavenRange(constraint)
@@ -215,7 +225,7 @@ func (p *Parser) parseConstraints(constraintsStr, scheme string) (*Range, error)
 
 	// Collect all intervals - they form a union
 	// Then intersect overlapping intervals to form proper ranges
-	result := intersectConsecutiveIntervals(intervals)
+	result := intersectConsecutiveIntervals(intervals, scheme)
 
 	// If we only have exclusions and no other constraints, start with unbounded range
 	if result == nil {
@@ -226,20 +236,23 @@ func (p *Parser) parseConstraints(constraintsStr, scheme string) (*Range, error)
 		}
 	}
 	result.Exclusions = exclusions
+	result.Scheme = scheme
 	return result, nil
 }
 
 // intersectConsecutiveIntervals handles VERS constraint semantics:
 // - Consecutive unbounded intervals (like >=X followed by <Y) are intersected to form a range
 // - Bounded intervals (exact versions) are unioned
-func intersectConsecutiveIntervals(intervals []Interval) *Range {
+func intersectConsecutiveIntervals(intervals []Interval, scheme string) *Range {
 	if len(intervals) == 0 {
 		return nil
 	}
 	if len(intervals) == 1 {
 		return NewRange(intervals)
 	}
 
+	cmp := compareFuncFor(scheme)
+
 	var resultIntervals []Interval
 	i := 0
 	for i < len(intervals) {
@@ -252,7 +265,7 @@ func intersectConsecutiveIntervals(intervals []Interval) *Range {
 			if (current.Min != "" && current.Max == "" && next.Max != "" && next.Min == "") ||
 				(current.Max != "" && current.Min == "" && next.Min != "" && next.Max == "") {
 				intersection := current.Intersect(next)
-				if !intersection.IsEmpty() {
+				if !intersection.isEmptyCmp(cmp) {
 					resultIntervals = append(resultIntervals, intersection)
 					i += 2
 					continue
@@ -295,7 +308,7 @@ func (p *Parser) parseNpmRange(s string) (*Range, error) {
 			}
 		}
 		return &Range{
-			Intervals:      mergeIntervals(allIntervals),
+			Intervals:      mergeIntervals(allIntervals, CompareVersions),
 			Exclusions:     allExclusions,
 			RawConstraints: allRaw,
 		}, nil
@@ -572,22 +585,53 @@ func (p *Parser) parsePessimisticRange(version string) (*Range, error) {
 func (p *Parser) parsePypiRange(s string) (*Range, error) {
 	s = strings.TrimSpace(s)
 
+	// Comma is AND in PEP 440: parse each specifier and intersect.
+	if strings.Contains(s, ",") {
+		var result *Range
+		for _, part := range strings.Split(s, ",") {
+			r, err := p.parsePypiRange(part)
+			if err != nil {
+				return nil, err
+			}
+			if result == nil {
+				result = r
+			} else {
+				result = result.Intersect(r)
+			}
+		}
+		return result, nil
+	}
+
 	// Compatible release: ~=1.4.2
 	if strings.HasPrefix(s, "~=") {
 		version := strings.TrimSpace(s[2:])
-		return p.parsePessimisticRange(version)
-	}
-
-	// Comma-separated constraints
-	if strings.Contains(s, ",") {
-		parts := strings.Split(s, ",")
-		constraintStr := strings.Join(parts, "|")
-		return p.parseConstraints(constraintStr, "pypi")
+		return p.parsePypiCompatibleRelease(version)
 	}
 
 	return p.parseConstraints(s, "pypi")
 }
 
+// parsePypiCompatibleRelease handles PEP 440 ~= by deriving the upper bound
+// from release segments (ignoring pre/post/dev) and preserving the epoch.
+func (p *Parser) parsePypiCompatibleRelease(version string) (*Range, error) {
+	upper, ok := pep440CompatibleUpper(version)
+	var r *Range
+	if ok {
+		r = NewRange([]Interval{NewInterval(version, upper, true, false)})
+	} else {
+		// Fall back to the generic pessimistic algorithm when the
+		// version is not valid PEP 440 or has fewer than two release
+		// segments.
+		var err error
+		r, err = p.parsePessimisticRange(version)
+		if err != nil {
+			return nil, err
+		}
+	}
+	r.Scheme = "pypi" //nolint:goconst
+	return r, nil
+}
+
 // maven: [1.0,2.0), (1.0,2.0], [1.0,)
 func (p *Parser) parseMavenRange(s string) (*Range, error) {
 	s = strings.TrimSpace(s)
@@ -701,7 +745,7 @@ func (p *Parser) parseHexRange(s string) (*Range, error) {
 			}
 		}
 		return &Range{
-			Intervals:      mergeIntervals(allIntervals),
+			Intervals:      mergeIntervals(allIntervals, CompareVersions),
 			RawConstraints: allRaw,
 		}, nil
 	}