vers 1.0.3 → 1.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b753f78521c853cb7c511190af2d9722a20a1d5f503295da5b922ab020950c60
-  data.tar.gz: 5a4d226e512a2f71b7634e946272c79d2558db811d8a734d258e2a48663648a3
+  metadata.gz: 8ad669b5ca951e8a64ddd205d39e083b3a9836a67ca9ff25d99872a57658a560
+  data.tar.gz: d1aefb9f16a5a842ad05d4e427b538a565240cf3c21969542bf614199e8e1955
 SHA512:
-  metadata.gz: ff9ae01cbf359c8b76bb10e7e2741c2d70d119039076b520dfa4c3b2e40c022c96b23b72b2251c2d00005d0ae0c81caacc125903506c97f807e7b980a8d07dc6
-  data.tar.gz: 949060b4a56d8bc53b9ab42ec65eb98afd1fb50ba17108abd57fd98e9d5fa5abd299931b006a341ed813ac4df7d644222aa98205dd209ca30c7fa2f01df74e76
+  metadata.gz: 6b87591c17a303bf820c2667f25ac802569173737c8bd63d13c86bc5aedf6e606cc50d3906c08d526dd8c9e934559f0cdc7717e8e6c4cfbd8ae5473ebc53bb9c
+  data.tar.gz: 9a6cafa4929f8a71b699d6ce1171e574bb6c99aca17b89850e7bf232d1269727d00f6a15f1b9a870f8319913e77b0ec865fc5633866161cb989425c9eefc76ce

data/.gitmodules

@@ -0,0 +1,3 @@
+[submodule "test/vers-spec"]
+	path = test/vers-spec
+	url = https://github.com/package-url/vers-spec.git

data/CHANGELOG.md

@@ -7,6 +7,15 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [1.1.0] - 2026-02-24
+
+### Added
+- Scheme-specific version comparison for Maven and NuGet via `Version.compare_with_scheme` and `Vers.compare_with_scheme`
+- `Vers::MavenVersion` module with Maven qualifier ordering (alpha < beta < milestone < rc < snapshot < release < sp), digit/letter transitions, sublist rules, qualifier aliases, and trailing zero normalization
+- `Vers::NuGetVersion` module with 4-part numeric versions, case-insensitive prereleases, and build metadata stripping
+- `scheme` parameter threaded through `Interval`, `VersionRange`, `Constraint`, and `Parser` so Maven and NuGet ranges use their own comparison rules in `contains?`, `intersect`, and other interval operations
+- 1010 conformance test cases from the vers-spec test suite for Maven and NuGet version comparison
+
 ## [1.0.3] - 2026-01-09
 
 ### Added
@@ -117,7 +126,8 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - **No runtime dependencies** - pure Ruby implementation
 - **Minitest** for testing (development dependency only)
 
-[Unreleased]: https://github.com/andrew/vers/compare/v1.0.3...HEAD
+[Unreleased]: https://github.com/andrew/vers/compare/v1.1.0...HEAD
+[1.1.0]: https://github.com/andrew/vers/compare/v1.0.3...v1.1.0
 [1.0.3]: https://github.com/andrew/vers/compare/v1.0.2...v1.0.3
 [1.0.2]: https://github.com/andrew/vers/compare/v1.0.1...v1.0.2
 [1.0.1]: https://github.com/andrew/vers/compare/v1.0.0...v1.0.1

data/lib/vers/constraint.rb

@@ -93,21 +93,21 @@ module Vers
     #   Vers::Constraint.new(">=", "1.2.3").to_interval  # => [1.2.3,+∞)
     #   Vers::Constraint.new("=", "1.0.0").to_interval   # => [1.0.0,1.0.0]
     #
-    def to_interval
+    def to_interval(scheme: nil)
       case operator
       when "="
-        Interval.exact(version)
+        Interval.exact(version, scheme: scheme)
       when "!="
         # != constraints need special handling in ranges - they create exclusions
         nil
       when ">"
-        Interval.greater_than(version, inclusive: false)
+        Interval.greater_than(version, inclusive: false, scheme: scheme)
       when ">="
-        Interval.greater_than(version, inclusive: true)
+        Interval.greater_than(version, inclusive: true, scheme: scheme)
       when "<"
-        Interval.less_than(version, inclusive: false)
+        Interval.less_than(version, inclusive: false, scheme: scheme)
       when "<="
-        Interval.less_than(version, inclusive: true)
+        Interval.less_than(version, inclusive: true, scheme: scheme)
       end
     end
 

data/lib/vers/interval.rb

@@ -4,35 +4,36 @@ require_relative 'version'
 
 module Vers
   class Interval
-    attr_reader :min, :max, :min_inclusive, :max_inclusive
+    attr_reader :min, :max, :min_inclusive, :max_inclusive, :scheme
 
-    def initialize(min: nil, max: nil, min_inclusive: true, max_inclusive: true)
+    def initialize(min: nil, max: nil, min_inclusive: true, max_inclusive: true, scheme: nil)
       @min = min
       @max = max
       @min_inclusive = min_inclusive
       @max_inclusive = max_inclusive
+      @scheme = scheme
 
       validate_bounds!
     end
 
-    def self.empty
-      new(min: "1", max: "0", min_inclusive: true, max_inclusive: true)
+    def self.empty(scheme: nil)
+      new(min: "1", max: "0", min_inclusive: true, max_inclusive: true, scheme: scheme)
     end
 
-    def self.unbounded
-      new
+    def self.unbounded(scheme: nil)
+      new(scheme: scheme)
     end
 
-    def self.exact(version)
-      new(min: version, max: version, min_inclusive: true, max_inclusive: true)
+    def self.exact(version, scheme: nil)
+      new(min: version, max: version, min_inclusive: true, max_inclusive: true, scheme: scheme)
     end
 
-    def self.greater_than(version, inclusive: false)
-      new(min: version, min_inclusive: inclusive)
+    def self.greater_than(version, inclusive: false, scheme: nil)
+      new(min: version, min_inclusive: inclusive, scheme: scheme)
     end
 
-    def self.less_than(version, inclusive: false)
-      new(max: version, max_inclusive: inclusive)
+    def self.less_than(version, inclusive: false, scheme: nil)
+      new(max: version, max_inclusive: inclusive, scheme: scheme)
     end
 
     def empty?
@@ -59,7 +60,8 @@ module Vers
     end
 
     def intersect(other)
-      return self.class.empty if empty? || other.empty?
+      merged_scheme = @scheme || other.scheme
+      return self.class.empty(scheme: merged_scheme) if empty? || other.empty?
 
       new_min = nil
       new_min_inclusive = true
@@ -110,7 +112,8 @@ module Vers
         min: new_min,
         max: new_max,
         min_inclusive: new_min_inclusive,
-        max_inclusive: new_max_inclusive
+        max_inclusive: new_max_inclusive,
+        scheme: merged_scheme
       )
     end
 
@@ -120,6 +123,7 @@ module Vers
 
       return nil unless overlaps?(other) || adjacent?(other)
 
+      merged_scheme = @scheme || other.scheme
       new_min = nil
       new_min_inclusive = true
       new_max = nil
@@ -169,7 +173,8 @@ module Vers
         min: new_min,
         max: new_max,
         min_inclusive: new_min_inclusive,
-        max_inclusive: new_max_inclusive
+        max_inclusive: new_max_inclusive,
+        scheme: merged_scheme
       )
     end
 
@@ -221,9 +226,12 @@ module Vers
       return 0 if a == b
       return -1 if a.nil?
       return 1 if b.nil?
-      
-      # Use the Version class for comparison
-      Version.compare(a, b)
+
+      if @scheme
+        Version.compare_with_scheme(a, b, @scheme)
+      else
+        Version.compare(a, b)
+      end
     end
   end
 end

data/lib/vers/maven_version.rb

@@ -0,0 +1,218 @@
+# frozen_string_literal: true
+
+module Vers
+  module MavenVersion
+    MavenComponent = Struct.new(:is_numeric, :numeric, :qualifier, :is_null, :after_dash, keyword_init: true) do
+      def initialize(is_numeric: false, numeric: 0, qualifier: "", is_null: false, after_dash: false)
+        super
+      end
+    end
+
+    QUALIFIER_ORDER = {
+      "alpha" => 1,
+      "beta" => 2,
+      "milestone" => 3,
+      "rc" => 4,
+      "snapshot" => 5,
+      "" => 6,
+      "sp" => 7
+    }.freeze
+
+    UNKNOWN_QUALIFIER_ORDER = 8
+
+    module_function
+
+    def compare(a, b)
+      return 0 if a == b
+
+      parts_a = parse_maven_version(a)
+      parts_b = parse_maven_version(b)
+
+      max_len = [parts_a.length, parts_b.length].max
+
+      max_len.times do |i|
+        comp_a = i < parts_a.length ? parts_a[i] : MavenComponent.new(is_null: true)
+        comp_b = i < parts_b.length ? parts_b[i] : MavenComponent.new(is_null: true)
+
+        cmp = compare_components(comp_a, comp_b)
+        return cmp unless cmp == 0
+      end
+
+      0
+    end
+
+    def parse_maven_version(s)
+      s = s.downcase
+
+      parts, after_dash_flags = split_with_separators(s)
+
+      result = []
+      parts.each_with_index do |part, i|
+        next if part.empty?
+
+        next_is_digit = if i + 1 < parts.length
+                          parts[i + 1].match?(/\A\d+\z/)
+                        else
+                          false
+                        end
+
+        normalized = normalize_qualifier(part, next_is_digit)
+        next if normalized.empty?
+
+        after_dash = i < after_dash_flags.length ? after_dash_flags[i] : false
+
+        if normalized.match?(/\A\d+\z/)
+          result << MavenComponent.new(is_numeric: true, numeric: normalized.to_i, after_dash: after_dash)
+        else
+          result << MavenComponent.new(qualifier: normalized, after_dash: after_dash)
+        end
+      end
+
+      normalize_components(result)
+    end
+
+    def split_with_separators(s)
+      parts = []
+      after_dash = []
+      current = +""
+      last_was_digit = false
+      first_char = true
+      current_after_dash = false
+
+      s.each_char do |c|
+        if c == "." || c == "-"
+          if current.length > 0
+            parts << current
+            after_dash << current_after_dash
+            current = +""
+          end
+          current_after_dash = (c == "-")
+          first_char = true
+          next
+        end
+
+        is_digit = c >= "0" && c <= "9"
+
+        if !first_char && is_digit != last_was_digit && current.length > 0
+          parts << current
+          after_dash << current_after_dash
+          current = +""
+          current_after_dash = true
+        end
+
+        current << c
+        last_was_digit = is_digit
+        first_char = false
+      end
+
+      if current.length > 0
+        parts << current
+        after_dash << current_after_dash
+      end
+
+      [parts, after_dash]
+    end
+
+    def normalize_qualifier(q, next_is_digit)
+      if next_is_digit && q.length == 1
+        case q
+        when "a" then return "alpha"
+        when "b" then return "beta"
+        when "m" then return "milestone"
+        end
+      end
+
+      case q
+      when "cr" then "rc"
+      when "ga", "final", "release" then ""
+      else q
+      end
+    end
+
+    def normalize_components(components)
+      return components if components.empty?
+
+      first_sublist_idx = components.index { |c| c.after_dash }
+
+      if first_sublist_idx && first_sublist_idx > 0
+        base_end = first_sublist_idx
+        while base_end > 1 && components[base_end - 1].is_numeric && components[base_end - 1].numeric == 0
+          base_end -= 1
+        end
+        if base_end < first_sublist_idx
+          components = components[0...base_end] + components[first_sublist_idx..]
+        end
+      elsif first_sublist_idx.nil?
+        while components.length > 0 && components.last.is_numeric && components.last.numeric == 0
+          components.pop
+        end
+      end
+
+      components
+    end
+
+    def compare_components(a, b)
+      return 0 if a.is_null && b.is_null
+
+      if a.is_null
+        return compare_to_null(b) * -1
+      end
+      if b.is_null
+        return compare_to_null(a)
+      end
+
+      if a.after_dash != b.after_dash
+        if a.after_dash
+          return b.is_numeric ? -1 : 1
+        else
+          return a.is_numeric ? 1 : -1
+        end
+      end
+
+      if a.is_numeric && b.is_numeric
+        return a.numeric <=> b.numeric
+      end
+
+      if a.is_numeric && !b.is_numeric
+        return 1
+      end
+      if !a.is_numeric && b.is_numeric
+        return -1
+      end
+
+      order_a = qualifier_order(a.qualifier)
+      order_b = qualifier_order(b.qualifier)
+
+      if order_a != order_b
+        return order_a <=> order_b
+      end
+
+      known_a = QUALIFIER_ORDER.key?(a.qualifier)
+      known_b = QUALIFIER_ORDER.key?(b.qualifier)
+
+      if !known_a && !known_b
+        return a.qualifier <=> b.qualifier
+      end
+
+      0
+    end
+
+    def compare_to_null(comp)
+      if comp.is_numeric
+        if comp.numeric == 0
+          0
+        else
+          1
+        end
+      else
+        order_comp = qualifier_order(comp.qualifier)
+        order_null = QUALIFIER_ORDER[""]
+        order_comp <=> order_null
+      end
+    end
+
+    def qualifier_order(q)
+      QUALIFIER_ORDER.fetch(q, UNKNOWN_QUALIFIER_ORDER)
+    end
+  end
+end

data/lib/vers/nuget_version.rb

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+module Vers
+  module NuGetVersion
+    module_function
+
+    def compare(a, b)
+      return 0 if a == b
+
+      parts_a = parse_nuget(a)
+      parts_b = parse_nuget(b)
+
+      4.times do |i|
+        cmp = parts_a[:numeric][i] <=> parts_b[:numeric][i]
+        return cmp unless cmp == 0
+      end
+
+      pre_a = parts_a[:prerelease]
+      pre_b = parts_b[:prerelease]
+
+      return 1 if pre_a.empty? && !pre_b.empty?
+      return -1 if !pre_a.empty? && pre_b.empty?
+      return 0 if pre_a.empty? && pre_b.empty?
+
+      compare_prerelease(pre_a, pre_b)
+    end
+
+    def parse_nuget(s)
+      s = s.dup
+
+      if (idx = s.index("+"))
+        s = s[0...idx]
+      end
+
+      prerelease = ""
+      if (idx = s.index("-"))
+        prerelease = s[(idx + 1)..]
+        s = s[0...idx]
+      end
+
+      numeric = [0, 0, 0, 0]
+      parts = s.split(".")
+      parts.each_with_index do |part, i|
+        break if i >= 4
+        numeric[i] = part.to_i
+      end
+
+      { numeric: numeric, prerelease: prerelease }
+    end
+
+    def compare_prerelease(a, b)
+      parts_a = a.downcase.split(".")
+      parts_b = b.downcase.split(".")
+
+      max_len = [parts_a.length, parts_b.length].max
+
+      max_len.times do |i|
+        part_a = i < parts_a.length ? parts_a[i] : nil
+        part_b = i < parts_b.length ? parts_b[i] : nil
+
+        return -1 if part_a.nil?
+        return 1 if part_b.nil?
+
+        num_a = part_a.match?(/\A\d+\z/) ? part_a.to_i : nil
+        num_b = part_b.match?(/\A\d+\z/) ? part_b.to_i : nil
+
+        if num_a && num_b
+          cmp = num_a <=> num_b
+          return cmp unless cmp == 0
+        else
+          cmp = part_a <=> part_b
+          return cmp unless cmp == 0
+        end
+      end
+
+      0
+    end
+  end
+end

data/lib/vers/parser.rb

@@ -83,8 +83,14 @@ module Vers
         parse_pypi_range(range_string)
       when "maven"
         parse_maven_range(range_string)
+      when "cargo"
+        parse_npm_range(range_string)
       when "nuget"
         parse_nuget_range(range_string)
+      when "hex", "elixir"
+        parse_hex_range(range_string)
+      when "go", "golang"
+        parse_go_range(range_string)
       when "deb", "debian"
         parse_debian_range(range_string)
       when "rpm"
@@ -103,22 +109,33 @@ module Vers
     # @return [String] The vers URI string
     #
     def to_vers_string(version_range, scheme)
-      return "*" if version_range.unbounded?
+      return "vers:#{scheme}/*" if version_range.unbounded?
       return "vers:#{scheme}/" if version_range.empty?
 
+      intervals = version_range.raw_constraints || version_range.intervals
       constraints = []
-      
-      version_range.intervals.each do |interval|
+
+      # Detect != pattern: two intervals (-∞,V) ∪ (V,+∞)
+      if intervals.length == 2
+        a, b = intervals
+        if a.min.nil? && !a.max_inclusive && b.max.nil? && !b.min_inclusive && a.max == b.min
+          constraints << "!=#{a.max}"
+          constraints.sort_by! { |c| sort_key_for_constraint(c) }
+          return "vers:#{scheme}/#{constraints.join('|')}"
+        end
+      end
+
+      intervals.each do |interval|
         if interval.min == interval.max && interval.min_inclusive && interval.max_inclusive
           # Exact version
-          constraints << "=#{interval.min}"
+          constraints << interval.min.to_s
         else
           # Range constraints
           if interval.min
             operator = interval.min_inclusive ? ">=" : ">"
             constraints << "#{operator}#{interval.min}"
           end
-          
+
           if interval.max
             operator = interval.max_inclusive ? "<=" : "<"
             constraints << "#{operator}#{interval.max}"
@@ -126,30 +143,45 @@ module Vers
         end
       end
 
+      constraints.sort_by! { |c| sort_key_for_constraint(c) }
+
       "vers:#{scheme}/#{constraints.join('|')}"
     end
 
     private
 
+    def sort_key_for_constraint(constraint)
+      version = constraint.sub(/\A[><=!]+/, '')
+      v = Version.cached_new(version)
+      [v, constraint]
+    end
+
     def parse_constraints(constraints_string, scheme)
-      constraint_strings = constraints_string.split('|')
+      constraint_strings = constraints_string.split(/[|,]/)
       intervals = []
       exclusions = []
+      interval_scheme = %w[maven nuget].include?(scheme) ? scheme : nil
 
       constraint_strings.each do |constraint_string|
         constraint = Constraint.parse(constraint_string.strip)
-        
+
         if constraint.exclusion?
           exclusions << constraint.version
         else
-          interval = constraint.to_interval
+          interval = constraint.to_interval(scheme: interval_scheme)
           intervals << interval if interval
         end
       end
 
-      # Start with the union of all positive constraints
-      range = VersionRange.new(intervals)
-      
+      # Start with the union of all positive constraints, or unbounded if only exclusions
+      range = if intervals.any?
+                VersionRange.new(intervals, scheme: interval_scheme)
+              elsif exclusions.any?
+                VersionRange.unbounded
+              else
+                VersionRange.new([], scheme: interval_scheme)
+              end
+
       # Apply exclusions
       exclusions.each do |version|
         range = range.exclude(version)
@@ -168,7 +200,7 @@ module Vers
       # Handle || (OR) operator
       if range_string.include?('||')
         or_parts = range_string.split('||').map(&:strip)
-        ranges = or_parts.map { |part| parse_npm_single_range(part) }
+        ranges = or_parts.map { |part| parse_npm_range(part) }
         return ranges.reduce { |acc, range| acc.union(range) }
       end
 
@@ -179,8 +211,23 @@ module Vers
 
       # Handle space-separated AND constraints
       and_parts = range_string.split(/\s+/).reject(&:empty?)
-      ranges = and_parts.map { |part| parse_npm_single_range(part) }
-      ranges.reduce { |acc, range| acc.intersect(range) }
+      # Re-join bare operators with their version
+      merged = []
+      and_parts.each do |part|
+        if merged.last&.match?(/\A(>=|<=|!=|[<>=~^])\z/)
+          merged[-1] = "#{merged.last}#{part}"
+        else
+          merged << part
+        end
+      end
+      ranges = merged.map { |part| parse_npm_single_range(part) }
+      # If all parts are bare versions (no operators), treat as union
+      all_exact = merged.all? { |part| part.match?(/\A\d/) }
+      if all_exact
+        ranges.reduce { |acc, range| acc.union(range) }
+      else
+        ranges.reduce { |acc, range| acc.intersect(range) }
+      end
     end
 
     def parse_npm_single_range(range_string)
@@ -230,8 +277,25 @@ module Vers
                  # Invalid patterns that should raise errors
                  raise ArgumentError, "Invalid NPM range format: #{range_string}"
                else
+                 # Check for operator + x-range (e.g. ">=2.2.x", ">=1.x")
+                 if range_string.match(/\A[><=]+(\d+)\.[xX*]\z/)
+                   major = $1.to_i
+                   return VersionRange.new([
+                     Interval.new(min: "#{major}.0.0", max: "#{major + 1}.0.0", min_inclusive: true, max_inclusive: false)
+                   ])
+                 end
+                 if range_string.match(/\A[><=]+(\d+)\.(\d+)\.[xX*]\z/)
+                   major = $1.to_i
+                   minor = $2.to_i
+                   return VersionRange.new([
+                     Interval.new(min: "#{major}.#{minor}.0", max: "#{major}.#{minor + 1}.0", min_inclusive: true, max_inclusive: false)
+                   ])
+                 end
                  # Standard constraint
                  constraint = Constraint.parse(range_string)
+                 # Normalize version to semver (npm always uses 3 segments)
+                 normalized_version = Version.cached_new(constraint.version).to_s
+                 constraint = Constraint.new(constraint.operator, normalized_version)
                  if constraint.exclusion?
                    VersionRange.unbounded.exclude(constraint.version)
                  else
@@ -263,9 +327,27 @@ module Vers
 
     def parse_tilde_range(version)
       v = Version.cached_new(version)
-      upper_version = if v.minor
+
+      if v.prerelease
+        # ~0.8.0-pre := >=0.8.0-pre <0.8.0 OR >=0.8.0 <0.8.1
+        # Prereleases only match their own major.minor.patch
+        base = "#{v.major}.#{v.minor || 0}.#{v.patch || 0}"
+        next_patch = "#{v.major}.#{v.minor || 0}.#{(v.patch || 0) + 1}"
+        pre_range = VersionRange.new([
+          Interval.new(min: version, max: base, min_inclusive: true, max_inclusive: false)
+        ])
+        release_range = VersionRange.new([
+          Interval.new(min: base, max: next_patch, min_inclusive: true, max_inclusive: false)
+        ])
+        return pre_range.union(release_range)
+      end
+
+      upper_version = if v.patch
                         # ~1.2.3 := >=1.2.3 <1.3.0
                         "#{v.major}.#{v.minor + 1}.0"
+                      elsif v.minor
+                        # ~1.2 := >=1.2.0 <1.3.0
+                        "#{v.major}.#{v.minor + 1}.0"
                       else
                         # ~1 := >=1.0.0 <2.0.0
                         "#{v.major + 1}.0.0"
@@ -292,14 +374,14 @@ module Vers
     def parse_pessimistic_range(version)
       v = Version.cached_new(version)
       upper_version = if v.patch
-                        # ~> 1.2.3 := >= 1.2.3, < 1.3.0
-                        "#{v.major}.#{v.minor + 1}.0"
+                        # ~> 1.2.3 := >= 1.2.3, < 1.3
+                        "#{v.major}.#{v.minor + 1}"
                       elsif v.minor
-                        # ~> 1.2 := >= 1.2.0, < 2.0.0
-                        "#{v.major + 1}.0.0"
+                        # ~> 1.2 := >= 1.2.0, < 2
+                        "#{v.major + 1}"
                       else
-                        # ~> 1 := >= 1.0.0, < 2.0.0
-                        "#{v.major + 1}.0.0"
+                        # ~> 1 := >= 1.0.0, < 2
+                        "#{v.major + 1}"
                       end
 
       VersionRange.new([
@@ -323,70 +405,70 @@ module Vers
           raise ArgumentError, "Malformed Maven range: mismatched brackets in '#{range_string}'"
         end
       end
-      
+
       case range_string
       when /^\[([^,]+),([^,]+)\]$/
         # [1.0,2.0] := >=1.0 <=2.0
         min_version = Regexp.last_match(1).strip
         max_version = Regexp.last_match(2).strip
         VersionRange.new([
-          Interval.new(min: min_version, max: max_version, min_inclusive: true, max_inclusive: true)
-        ])
+          Interval.new(min: min_version, max: max_version, min_inclusive: true, max_inclusive: true, scheme: "maven")
+        ], scheme: "maven")
       when /^\(([^,]+),([^,]+)\)$/
         # (1.0,2.0) := >1.0 <2.0
         min_version = Regexp.last_match(1).strip
         max_version = Regexp.last_match(2).strip
         VersionRange.new([
-          Interval.new(min: min_version, max: max_version, min_inclusive: false, max_inclusive: false)
-        ])
+          Interval.new(min: min_version, max: max_version, min_inclusive: false, max_inclusive: false, scheme: "maven")
+        ], scheme: "maven")
       when /^\[([^,]+),([^,]+)\)$/
         # [1.0,2.0) := >=1.0 <2.0
         min_version = Regexp.last_match(1).strip
         max_version = Regexp.last_match(2).strip
         VersionRange.new([
-          Interval.new(min: min_version, max: max_version, min_inclusive: true, max_inclusive: false)
-        ])
+          Interval.new(min: min_version, max: max_version, min_inclusive: true, max_inclusive: false, scheme: "maven")
+        ], scheme: "maven")
       when /^\(([^,]+),([^,]+)\]$/
         # (1.0,2.0] := >1.0 <=2.0
         min_version = Regexp.last_match(1).strip
         max_version = Regexp.last_match(2).strip
         VersionRange.new([
-          Interval.new(min: min_version, max: max_version, min_inclusive: false, max_inclusive: true)
-        ])
+          Interval.new(min: min_version, max: max_version, min_inclusive: false, max_inclusive: true, scheme: "maven")
+        ], scheme: "maven")
       when /^\[([^,]+)\]$/
         # [1.0] := exactly 1.0
         version = Regexp.last_match(1).strip
-        VersionRange.exact(version)
+        VersionRange.exact(version, scheme: "maven")
       when /^\[([^,]+),\)$/
         # [1.0,) := >=1.0
         min_version = Regexp.last_match(1).strip
         VersionRange.new([
-          Interval.new(min: min_version, min_inclusive: true)
-        ])
+          Interval.new(min: min_version, min_inclusive: true, scheme: "maven")
+        ], scheme: "maven")
       when /^\(([^,]+),\)$/
         # (1.0,) := >1.0
         min_version = Regexp.last_match(1).strip
         VersionRange.new([
-          Interval.new(min: min_version, min_inclusive: false)
-        ])
+          Interval.new(min: min_version, min_inclusive: false, scheme: "maven")
+        ], scheme: "maven")
       when /^\(,([^,]+)\]$/
         # (,1.0] := <=1.0
         max_version = Regexp.last_match(1).strip
         VersionRange.new([
-          Interval.new(max: max_version, max_inclusive: true)
-        ])
+          Interval.new(max: max_version, max_inclusive: true, scheme: "maven")
+        ], scheme: "maven")
       when /^\(,([^,]+)\)$/
         # (,1.0) := <1.0
         max_version = Regexp.last_match(1).strip
         VersionRange.new([
-          Interval.new(max: max_version, max_inclusive: false)
-        ])
+          Interval.new(max: max_version, max_inclusive: false, scheme: "maven")
+        ], scheme: "maven")
       when /^[0-9]/
         # Simple version number without brackets - in Maven, this is minimum version
         if range_string.match(/^[0-9]+(\.[0-9]+)*(-[a-zA-Z0-9.-]+)?$/)
           VersionRange.new([
-            Interval.new(min: range_string, min_inclusive: true)
-          ])
+            Interval.new(min: range_string, min_inclusive: true, scheme: "maven")
+          ], scheme: "maven")
         else
           parse_constraints(range_string, 'maven')
         end
@@ -400,7 +482,7 @@ module Vers
           # Find all individual ranges by splitting on comma between brackets
           individual_ranges = []
           remaining = range_string.strip
-          
+
           while remaining.length > 0
             # Find the next complete bracket range
             if match = remaining.match(/^[\[\(][^\[\]\(\)]*[\]\)]/)
@@ -412,7 +494,7 @@ module Vers
               break
             end
           end
-          
+
           if individual_ranges.length > 1
             individual_ranges.each do |range_part|
               begin
@@ -422,13 +504,13 @@ module Vers
                 # If parsing fails, skip this part
               end
             end
-            
+
             if ranges.any?
               return ranges.reduce { |acc, range| acc.union(range) }
             end
           end
         end
-        
+
         # Fall back to standard constraint parsing
         parse_constraints(range_string, 'maven')
       else
@@ -443,19 +525,147 @@ module Vers
       # But simple version strings like "1.0" are minimum versions, not exact
       case range_string
       when /^[\[\(].+[\]\)]$/
-        # Use Maven parsing for bracket notation
-        parse_maven_range(range_string)
+        # Parse bracket notation like Maven but with nuget scheme
+        range = parse_nuget_bracket_range(range_string)
+        range
       when /^[0-9]/
         # Simple version number - treat as minimum version for NuGet
         VersionRange.new([
-          Interval.new(min: range_string, min_inclusive: true)
-        ])
+          Interval.new(min: range_string, min_inclusive: true, scheme: "nuget")
+        ], scheme: "nuget")
       else
         # Fall back to standard constraint parsing
         parse_constraints(range_string, 'nuget')
       end
     end
 
+    def parse_nuget_bracket_range(range_string)
+      case range_string
+      when /^\[([^,]+),([^,]+)\]$/
+        min_v = Regexp.last_match(1).strip
+        max_v = Regexp.last_match(2).strip
+        VersionRange.new([
+          Interval.new(min: min_v, max: max_v, min_inclusive: true, max_inclusive: true, scheme: "nuget")
+        ], scheme: "nuget")
+      when /^\(([^,]+),([^,]+)\)$/
+        min_v = Regexp.last_match(1).strip
+        max_v = Regexp.last_match(2).strip
+        VersionRange.new([
+          Interval.new(min: min_v, max: max_v, min_inclusive: false, max_inclusive: false, scheme: "nuget")
+        ], scheme: "nuget")
+      when /^\[([^,]+),([^,]+)\)$/
+        min_v = Regexp.last_match(1).strip
+        max_v = Regexp.last_match(2).strip
+        VersionRange.new([
+          Interval.new(min: min_v, max: max_v, min_inclusive: true, max_inclusive: false, scheme: "nuget")
+        ], scheme: "nuget")
+      when /^\(([^,]+),([^,]+)\]$/
+        min_v = Regexp.last_match(1).strip
+        max_v = Regexp.last_match(2).strip
+        VersionRange.new([
+          Interval.new(min: min_v, max: max_v, min_inclusive: false, max_inclusive: true, scheme: "nuget")
+        ], scheme: "nuget")
+      when /^\[([^,]+)\]$/
+        version = Regexp.last_match(1).strip
+        VersionRange.exact(version, scheme: "nuget")
+      when /^\[([^,]+),\)$/
+        min_v = Regexp.last_match(1).strip
+        VersionRange.new([
+          Interval.new(min: min_v, min_inclusive: true, scheme: "nuget")
+        ], scheme: "nuget")
+      when /^\(([^,]+),\)$/
+        min_v = Regexp.last_match(1).strip
+        VersionRange.new([
+          Interval.new(min: min_v, min_inclusive: false, scheme: "nuget")
+        ], scheme: "nuget")
+      when /^\(,([^,]+)\]$/
+        max_v = Regexp.last_match(1).strip
+        VersionRange.new([
+          Interval.new(max: max_v, max_inclusive: true, scheme: "nuget")
+        ], scheme: "nuget")
+      when /^\(,([^,]+)\)$/
+        max_v = Regexp.last_match(1).strip
+        VersionRange.new([
+          Interval.new(max: max_v, max_inclusive: false, scheme: "nuget")
+        ], scheme: "nuget")
+      else
+        parse_constraints(range_string, 'nuget')
+      end
+    end
+
+    # Hex/Elixir range parsing
+    def parse_hex_range(range_string)
+      # Handle "or" disjunction first
+      if range_string.include?(" or ")
+        or_parts = range_string.split(" or ").map(&:strip)
+        ranges = or_parts.map { |part| parse_hex_single_range(part) }
+        return ranges.reduce { |acc, range| acc.union(range) }
+      end
+
+      parse_hex_single_range(range_string)
+    end
+
+    def parse_hex_single_range(range_string)
+      # Handle "and" conjunction and comma-separated AND constraints
+      if range_string.include?(" and ") || range_string.include?(",")
+        and_parts = range_string.split(/\s+and\s+|,/).map(&:strip).reject(&:empty?)
+        ranges = and_parts.map { |part| parse_hex_constraint(part) }
+        return ranges.reduce { |acc, range| acc.intersect(range) }
+      end
+
+      parse_hex_constraint(range_string)
+    end
+
+    def parse_hex_constraint(constraint_string)
+      if constraint_string.match(/^~>\s*(.+)$/)
+        parse_pessimistic_range(Regexp.last_match(1).strip)
+      else
+        # Normalize == to = for our internal constraint parsing
+        normalized = constraint_string.gsub("==", "=")
+        constraint = Constraint.parse(normalized.strip)
+        if constraint.exclusion?
+          VersionRange.unbounded.exclude(constraint.version)
+        else
+          VersionRange.new([constraint.to_interval])
+        end
+      end
+    end
+
+    # Go module range parsing (comma-separated AND constraints, v-prefix preserved)
+    def parse_go_range(range_string)
+      return VersionRange.unbounded if range_string.nil? || range_string.strip.empty?
+
+      unless range_string.include?(',')
+        return parse_constraints(range_string, 'go')
+      end
+
+      parts = range_string.split(',').map(&:strip)
+      constraint_intervals = []
+      exclusions = []
+
+      parts.each do |part|
+        constraint = Constraint.parse(part)
+        if constraint.exclusion?
+          exclusions << constraint.version
+        else
+          interval = constraint.to_interval
+          constraint_intervals << interval if interval
+        end
+      end
+
+      if constraint_intervals.any?
+        range = VersionRange.new([constraint_intervals.first])
+        constraint_intervals[1..].each do |interval|
+          range = range.intersect(VersionRange.new([interval]))
+        end
+      else
+        range = VersionRange.unbounded
+      end
+
+      exclusions.each { |version| range = range.exclude(version) }
+      range
+    end
+
     # Debian range parsing
     def parse_debian_range(range_string)
       # Debian uses operators like >=, <=, =, >>, <<

data/lib/vers/version.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 module Vers
-  VERSION = "1.0.3"
+  VERSION = "1.2.0"
 
   ##
   # Handles version comparison and normalization across different package ecosystems.
@@ -64,10 +64,29 @@ module Vers
       # Use cached versions for better performance
       version_a = cached_new(a)
       version_b = cached_new(b)
-      
+
       version_a <=> version_b
     end
 
+    ##
+    # Compares two version strings using scheme-specific rules
+    #
+    # @param a [String] First version string
+    # @param b [String] Second version string
+    # @param scheme [String, nil] Package manager scheme (maven, nuget, or nil for generic)
+    # @return [Integer] -1 if a < b, 0 if a == b, 1 if a > b
+    #
+    def self.compare_with_scheme(a, b, scheme)
+      case scheme
+      when "maven"
+        MavenVersion.compare(a, b)
+      when "nuget"
+        NuGetVersion.compare(a, b)
+      else
+        compare(a, b)
+      end
+    end
+
     ##
     # Normalizes a version string to a consistent format
     #
@@ -85,10 +104,12 @@ module Vers
     # @return [Boolean] true if the version is valid
     #
     def self.valid?(version_string)
-      cached_new(version_string)
-      true
-    rescue ArgumentError
-      false
+      version_string.to_s.match?(/\Av?\d+\.\d+\.\d+/)
+    end
+
+    def self.clean(version_string)
+      return nil unless valid?(version_string)
+      version_string.to_s.sub(/\Av/, '')
     end
 
     ##
@@ -295,6 +316,9 @@ module Vers
     private
 
     def parse_version
+      # Strip leading v/V prefix (e.g. "v1.0.0" -> "1.0.0")
+      @original = @original.sub(/\Av/i, '')
+
       # Handle simple numeric versions (optimized case)
       if @original.match(/^\d+$/)
         @major = @original.to_i

data/lib/vers/version_range.rb

@@ -5,31 +5,38 @@ require_relative 'version'
 
 module Vers
   class VersionRange
-    attr_reader :intervals
-
-    def initialize(intervals = [])
-      @intervals = intervals.compact.reject(&:empty?).sort_by { |i| [i.min || '', i.max || ''] }
+    attr_reader :intervals, :raw_constraints, :scheme
+
+    def initialize(intervals = [], raw_constraints: nil, scheme: nil)
+      @scheme = scheme
+      @intervals = intervals.compact.reject(&:empty?)
+      if @scheme
+        @intervals.sort! { |a, b| compare_interval_bounds(a, b) }
+      else
+        @intervals.sort_by! { |i| [i.min || '', i.max || ''] }
+      end
+      @raw_constraints = raw_constraints
       merge_overlapping_intervals!
     end
 
-    def self.empty
-      new([])
+    def self.empty(scheme: nil)
+      new([], scheme: scheme)
     end
 
-    def self.unbounded
-      new([Interval.unbounded])
+    def self.unbounded(scheme: nil)
+      new([Interval.unbounded(scheme: scheme)], scheme: scheme)
     end
 
-    def self.exact(version)
-      new([Interval.exact(version)])
+    def self.exact(version, scheme: nil)
+      new([Interval.exact(version, scheme: scheme)], scheme: scheme)
     end
 
-    def self.greater_than(version, inclusive: false)
-      new([Interval.greater_than(version, inclusive: inclusive)])
+    def self.greater_than(version, inclusive: false, scheme: nil)
+      new([Interval.greater_than(version, inclusive: inclusive, scheme: scheme)], scheme: scheme)
     end
 
-    def self.less_than(version, inclusive: false)
-      new([Interval.less_than(version, inclusive: inclusive)])
+    def self.less_than(version, inclusive: false, scheme: nil)
+      new([Interval.less_than(version, inclusive: inclusive, scheme: scheme)], scheme: scheme)
     end
 
     def empty?
@@ -45,38 +52,47 @@ module Vers
     end
 
     def intersect(other)
+      merged_scheme = @scheme || other.scheme
       result_intervals = []
-      
+
       intervals.each do |interval1|
         other.intervals.each do |interval2|
           intersection = interval1.intersect(interval2)
           result_intervals << intersection unless intersection.empty?
         end
       end
-      
-      self.class.new(result_intervals)
+
+      combined_raw = (raw_constraints || intervals) + (other.raw_constraints || other.intervals)
+      self.class.new(result_intervals, raw_constraints: combined_raw, scheme: merged_scheme)
     end
 
     def union(other)
-      self.class.new(intervals + other.intervals)
+      merged_scheme = @scheme || other.scheme
+      combined_raw = (raw_constraints || intervals) + (other.raw_constraints || other.intervals)
+      self.class.new(intervals + other.intervals, raw_constraints: combined_raw, scheme: merged_scheme)
     end
 
     def complement
-      return self.class.unbounded if empty?
-      return self.class.empty if unbounded?
+      return self.class.unbounded(scheme: @scheme) if empty?
+      return self.class.empty(scheme: @scheme) if unbounded?
 
       result_intervals = []
-      
-      sorted_intervals = intervals.sort_by { |i| i.min || '' }
-      
+
+      sorted_intervals = if @scheme
+                           intervals.sort { |a, b| compare_interval_bounds(a, b) }
+                         else
+                           intervals.sort_by { |i| i.min || '' }
+                         end
+
       first_interval = sorted_intervals.first
       if first_interval.min
         result_intervals << Interval.new(
           max: first_interval.min,
-          max_inclusive: !first_interval.min_inclusive
+          max_inclusive: !first_interval.min_inclusive,
+          scheme: @scheme
         )
       end
-      
+
       sorted_intervals.each_cons(2) do |curr, next_interval|
         if curr.max && next_interval.min
           comparison = version_compare(curr.max, next_interval.min)
@@ -85,53 +101,57 @@ module Vers
               min: curr.max,
               max: next_interval.min,
               min_inclusive: !curr.max_inclusive,
-              max_inclusive: !next_interval.min_inclusive
+              max_inclusive: !next_interval.min_inclusive,
+              scheme: @scheme
             )
           end
         end
       end
-      
+
       last_interval = sorted_intervals.last
       if last_interval.max
         result_intervals << Interval.new(
           min: last_interval.max,
-          min_inclusive: !last_interval.max_inclusive
+          min_inclusive: !last_interval.max_inclusive,
+          scheme: @scheme
         )
       end
-      
-      self.class.new(result_intervals)
+
+      self.class.new(result_intervals, scheme: @scheme)
     end
 
     def exclude(version)
       return self if !contains?(version)
-      
+
       result_intervals = []
-      
+
       intervals.each do |interval|
         if interval.contains?(version)
-          if interval.min && version_compare(interval.min, version) < 0
+          if interval.min.nil? || version_compare(interval.min, version) < 0
             result_intervals << Interval.new(
               min: interval.min,
               max: version,
               min_inclusive: interval.min_inclusive,
-              max_inclusive: false
+              max_inclusive: false,
+              scheme: @scheme
             )
           end
-          
-          if interval.max && version_compare(version, interval.max) < 0
+
+          if interval.max.nil? || version_compare(version, interval.max) < 0
             result_intervals << Interval.new(
               min: version,
               max: interval.max,
               min_inclusive: false,
-              max_inclusive: interval.max_inclusive
+              max_inclusive: interval.max_inclusive,
+              scheme: @scheme
             )
           end
         else
           result_intervals << interval
         end
       end
-      
-      self.class.new(result_intervals)
+
+      self.class.new(result_intervals, raw_constraints: raw_constraints, scheme: @scheme)
     end
 
     def to_s
@@ -165,9 +185,39 @@ module Vers
       return 0 if a == b
       return -1 if a.nil?
       return 1 if b.nil?
-      
-      # Use the Version class for comparison
-      Version.compare(a, b)
+
+      if @scheme
+        Version.compare_with_scheme(a, b, @scheme)
+      else
+        Version.compare(a, b)
+      end
+    end
+
+    def compare_interval_bounds(a, b)
+      min_a = a.min
+      min_b = b.min
+      min_cmp = if min_a.nil? && min_b.nil?
+                  0
+                elsif min_a.nil?
+                  -1
+                elsif min_b.nil?
+                  1
+                else
+                  version_compare(min_a, min_b)
+                end
+      return min_cmp unless min_cmp == 0
+
+      max_a = a.max
+      max_b = b.max
+      if max_a.nil? && max_b.nil?
+        0
+      elsif max_a.nil?
+        1
+      elsif max_b.nil?
+        -1
+      else
+        version_compare(max_a, max_b)
+      end
     end
   end
 end

data/lib/vers.rb

@@ -1,6 +1,8 @@
 # frozen_string_literal: true
 
 require_relative "vers/version"
+require_relative "vers/maven_version"
+require_relative "vers/nuget_version"
 require_relative "vers/interval"
 require_relative "vers/version_range"
 require_relative "vers/constraint"
@@ -117,13 +119,15 @@ module Vers
   #   Vers.satisfies?("1.5.0", "^1.2.3", "npm")            # => true
   #
   def self.satisfies?(version, constraint, scheme = nil)
-    range = if scheme
-              parse_native(constraint, scheme)
-            else
-              parse(constraint)
-            end
-    
-    range.contains?(version)
+    sub_ranges = constraint.split('||').map(&:strip).reject(&:empty?)
+    sub_ranges.any? do |sub_range|
+      range = if scheme
+                parse_native(sub_range, scheme)
+              else
+                parse(sub_range)
+              end
+      range.contains?(version)
+    end
   end
 
   ##
@@ -143,6 +147,18 @@ module Vers
     Version.compare(a, b)
   end
 
+  ##
+  # Compares two version strings using scheme-specific rules
+  #
+  # @param a [String] First version string
+  # @param b [String] Second version string
+  # @param scheme [String, nil] Package manager scheme (maven, nuget, or nil for generic)
+  # @return [Integer] -1 if a < b, 0 if a == b, 1 if a > b
+  #
+  def self.compare_with_scheme(a, b, scheme)
+    Version.compare_with_scheme(a, b, scheme)
+  end
+
   ##
   # Normalizes a version string to a consistent format
   #
@@ -163,6 +179,10 @@ module Vers
     Version.valid?(version_string)
   end
 
+  def self.clean(version_string)
+    Version.clean(version_string)
+  end
+
   ##
   # Creates an exact version range
   #

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: vers
 version: !ruby/object:Gem::Version
-  version: 1.0.3
+  version: 1.2.0
 platform: ruby
 authors:
 - Andrew Nesbitt
@@ -18,6 +18,7 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- ".gitmodules"
 - ".ruby-version"
 - CHANGELOG.md
 - CODE_OF_CONDUCT.md
@@ -30,6 +31,8 @@ files:
 - lib/vers.rb
 - lib/vers/constraint.rb
 - lib/vers/interval.rb
+- lib/vers/maven_version.rb
+- lib/vers/nuget_version.rb
 - lib/vers/parser.rb
 - lib/vers/version.rb
 - lib/vers/version_range.rb