vers 1.3.1 → 2.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9a8066da910f228939dadbc96afeadcf5122c99ed9a06a67b9858c4720d7e070
-  data.tar.gz: 59204f511b9adfb7863d97f754915fe96725093e6f0fa4dc7bfc3f2703e5e387
+  metadata.gz: e93f013566ede55047ab7d9ba9b328521e89f9eae2b9e5a21c589e6c3319ca45
+  data.tar.gz: 56e0c2ed53178935ed6548f0bc373a11343d2aa2d3de43bc51b888979c436578
 SHA512:
-  metadata.gz: e4af64390c9efd167082d891eb192f051a04e231a889e751a646e7ce93d55d5736c5f98368ca1b83b6e4adaebc7f962ce4282155eabc245c522ed142a63dda27
-  data.tar.gz: 119edf96cc65e3fc88d2f89b543ecbae593c6afeb136db0144793c981999476925ae5c671508965676b4d31d2a2cf1d4858feaaab45f443110561a5b74c00b06
+  metadata.gz: 30a8cb87c48bdb38480156560b03abcb16b9e3c1a4ff1a41726b824c7652b75782a3a6cfe2184290ed066281dcb8f478c0eb40150394e82b054314f39d4bdb86
+  data.tar.gz: f0ed8e70c9831e71fb17f3b058c2ab5b54d449352f0ec985f0c1c53962ef504e8f3d945278ad7c37af8847338078394bc9bb7e0d0317221486d1d501378bdf09

data/.ruby-version

@@ -1 +1 @@
-4.0.0
+4.0.6

data/CHANGELOG.md

@@ -7,6 +7,33 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [2.0.0] - 2026-08-28
+
+### Added
+
+- Bazel module version comparison, validation, normalization, cleaning, stable classification, and prerelease classification.
+- Scheme-aware comparison, validation, normalization, cleaning, stable classification, and prerelease classification across language registries, distribution packages, SemVer variants, and other version formats.
+- Native range parsing for Composer, Pub, Conan, OpenSSL, and nginx, with expanded behavior for existing npm, Cargo, RubyGems, PyPI, Maven, and NuGet parsers.
+- Data-driven comparison, containment, native conversion, validation, and canonical parsing tests from `vers-spec`, upstream package managers, and the Go implementation.
+
+### Changed
+
+- Version ranges retain their canonical scheme through containment and set operations, and reject algebra between incompatible schemes.
+- VERS serialization canonicalizes scheme aliases and rejects a scheme that conflicts with the range.
+- Canonical VERS parsing rejects uppercase types, whitespace, malformed pipes, invalid percent encoding, unencoded reserved characters, duplicate versions, and unsorted constraints when strict parsing is requested.
+- Typed wildcard ranges reject invalid candidate versions.
+- APK comparison and validation now follow apk-tools tokens instead of Gentoo version rules.
+- The minimum supported Ruby version is now 3.3.
+
+### Fixed
+
+- Unioning an unbounded interval with a bounded interval now remains unbounded.
+- Range unions retain exclusions when the other operand does not contain the excluded version.
+- VERS serialization no longer adds an empty constraint to unbounded ranges with exclusions.
+- SemVer comparison handles surrounding whitespace consistently with validation.
+- npm partial and prerelease ranges retain their membership after VERS serialization.
+- Cargo and PyPI intersections follow their scheme-specific build and local version equality rules.
+
 ## [1.1.0] - 2026-02-24
 
 ### Added
@@ -126,7 +153,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.1.0...HEAD
+[Unreleased]: https://github.com/andrew/vers/compare/v2.0.0...HEAD
+[2.0.0]: https://github.com/andrew/vers/compare/v1.3.1...v2.0.0
 [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

data/CONTRIBUTING.md

@@ -41,7 +41,7 @@ Enhancement suggestions are welcome! Please:
 
 ### Prerequisites
 
-- Ruby 3.2 or higher
+- Ruby 3.3 or higher
 - Bundler gem
 
 ### Setup
@@ -191,4 +191,4 @@ Provide clear, actionable error messages:
 - Suggest corrections when possible
 - Use specific exception types
 
-Thank you for contributing to make Vers better for everyone!
+Thank you for contributing to make Vers better for everyone!

data/README.md

@@ -1,10 +1,8 @@
 # Vers - Version Range Parser for Ruby
 
-A Ruby library for parsing, comparing and sorting versions according to the [VERS specification](https://github.com/package-url/purl-spec/blob/main/VERSION-RANGE-SPEC.rst).
+A Ruby library for parsing VERS ranges and applying package-manager version rules. It supports canonical VERS strings, native range syntax, scheme-aware comparison, validation, normalization, and release classification.
 
-This gem provides tools for working with version ranges across different package managers, using a mathematical interval model internally and supporting the vers specification from the Package URL (PURL) project.
-
-[![Ruby](https://img.shields.io/badge/ruby-%3E%3D%203.2-red.svg)](https://www.ruby-lang.org/)
+[![Ruby](https://img.shields.io/badge/ruby-%3E%3D%203.3-red.svg)](https://www.ruby-lang.org/)
 [![Gem Version](https://badge.fury.io/rb/vers.svg)](https://rubygems.org/gems/vers)
 [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
 
@@ -12,14 +10,11 @@ This gem provides tools for working with version ranges across different package
 
 ## Features
 
-- **Universal version range parsing** with support for 6 package ecosystems (npm, gem, pypi, maven, debian, rpm)
-- **Mathematical interval model** for precise set operations (union, intersection, complement)
-- **VERS specification compliance** with full support for the Package URL version range specification
-- **Native syntax support** - parse native package manager syntax (^1.2.3, ~>1.0, >=1.0,<2.0, [1.0,2.0))
-- **Bidirectional conversion** between native syntax and universal vers URI format
-- **Semantic versioning features** - version increment, constraint checking, prerelease handling
-- **Comprehensive error handling** with detailed parsing exceptions
-- **100% test coverage** with 113 tests and 366 assertions
+- Parse and serialize canonical VERS strings.
+- Parse native ranges for npm, Cargo, RubyGems, PyPI, Composer, Pub, Maven, NuGet, Hex, Go, Debian, RPM, Conan, OpenSSL, and nginx.
+- Compare, validate, normalize, clean, and classify versions with package-manager rules.
+- Combine ranges with union, intersection, complement, and exclusions.
+- Check containment with the range's version scheme.
 
 ## Installation
 
@@ -56,29 +51,37 @@ npm_range = Vers.parse_native("^1.2.3", "npm")
 gem_range = Vers.parse_native("~> 1.0", "gem")
 
 # Check version containment
-Vers.satisfies?("1.5.0", ">=1.0.0,<2.0.0")  # => true
+Vers.satisfies?("1.5.0", ">=1.0.0,<2.0.0", "pypi")  # => true
 
 # Compare versions
 Vers.compare("1.2.3", "1.2.4")  # => -1
 
+# Use Bazel's module version rules
+Vers.compare_with_scheme("0.7.1", "0.7.1.bcr.1", "bazel")  # => -1
+Vers.valid?("35.1", "bazel")                                # => true
+Vers.normalize("v01.02", "composer")                        # => "1.2.0"
+Vers.clean(" v1.2 ", "npm")                                 # => "1.2.0"
+Vers.stable?("0.7.1.bcr.1", "bazel")                        # => true
+Vers.prerelease?("36.0-rc2", "bazel")                       # => true
+
 # Version operations
 version = Vers::Version.new("1.2.3")
 version.increment_major  # => #<Vers::Version "2.0.0">
 version.satisfies?("~> 1.2")  # => true
 ```
 
-## Supported Package Managers
+## Version Schemes
+
+Scheme-aware version operations support these groups:
+
+- SemVer family: SemVer, npm, Cargo, Go modules, Hex, and nginx.
+- Language registries: RubyGems, PyPI, Composer, Pub, Maven, and NuGet.
+- Distribution packages: Debian, RPM, APK, Gentoo, and ALPM.
+- Other formats: Bazel, Conan, OpenSSL, integer-dot, RFC 3339 datetime, and lexicographic versions.
 
-- **npm** (Node.js): Caret ranges (^1.2.3), tilde ranges (~1.2.3), hyphen ranges (1.2.3 - 2.3.4), OR logic (||), wildcards (1.x, *)
-- **RubyGems** (Ruby): Pessimistic operator (~> 1.2), standard operators (>=, <=, etc.), comma-separated constraints
-- **PyPI** (Python): Comma-separated constraints (>=1.0,<2.0), exclusions (!=1.5.0), compatible release (~=1.4.2)
-- **Maven** (Java): Bracket notation ([1.0,2.0], (1.0,2.0)), union ranges, open ranges
-- **NuGet** (.NET): Bracket notation ([1.0,2.0], (1.0,2.0)), mixed brackets, open ranges
-- **Packagist** (PHP Composer): Caret ranges (^1.2.3), tilde ranges (~1.2), stability flags (@dev, @alpha)
-- **Debian** (apt): Standard comparison operators (>=1.0.0, <<2.0.0)
-- **RPM** (yum/dnf): Standard comparison operators (>=1.0.0, <=2.0.0)
+The aliases `rubygems`, `debian`, `golang`, `elixir`, and `alpine` map to their canonical schemes. Unknown schemes keep the generic version behavior. Bazel is an implementation-defined scheme in this library and remains separate from the VERS specification types.
 
-Many other package managers are also supported using standard comparison operators (>=, <=, <, >, =, !=), including Cargo (Rust), Go modules, and more.
+Native range parsing includes npm and Cargo caret, tilde, wildcard, hyphen, AND, and OR forms; Composer stability and branch forms; Pub caret ranges; RubyGems pessimistic ranges; PyPI specifiers; Maven and NuGet bracket ranges; Conan compatible ranges; OpenSSL exact-version lists; and nginx plus ranges. Other schemes accept standard VERS comparison operators.
 
 ## Mathematical Model
 
@@ -134,7 +137,7 @@ vers_string = Vers.to_vers_string(npm_range, "npm")
 puts vers_string  # => "vers:npm/>=1.2.3|<2.0.0"
 
 # Parse vers URI and use in your application
-range = Vers.parse("vers:gem/~>1.0")
+range = Vers.parse_native("~>1.0", "gem")
 puts range.contains?("1.5.0")  # => true
 ```
 

data/lib/vers/bazel_version.rb

@@ -0,0 +1,114 @@
+# frozen_string_literal: true
+
+module Vers
+  module BazelVersion
+    VERSION_REGEX = /\A(?<release>[a-zA-Z0-9.]+)(?:-(?<prerelease>[a-zA-Z0-9.-]+))?(?:\+[a-zA-Z0-9.-]+)?\z/
+    MAX_NUMERIC_IDENTIFIER = (2**64) - 1
+
+    Identifier = Struct.new(:numeric, :number, :text, keyword_init: true)
+    ParsedVersion = Struct.new(:release, :prerelease, :empty, keyword_init: true)
+
+    module_function
+
+    def compare(a, b)
+      return 0 if a == b
+
+      version_a = parse(a)
+      version_b = parse(b)
+
+      return 1 if version_a.empty && !version_b.empty
+      return -1 if !version_a.empty && version_b.empty
+
+      release_comparison = compare_identifiers(version_a.release, version_b.release)
+      return release_comparison unless release_comparison == 0
+
+      return 1 if version_a.prerelease.empty? && !version_b.prerelease.empty?
+      return -1 if !version_a.prerelease.empty? && version_b.prerelease.empty?
+
+      compare_identifiers(version_a.prerelease, version_b.prerelease)
+    end
+
+    def valid?(version)
+      return false if version == ""
+
+      parse(version)
+      true
+    rescue ArgumentError
+      false
+    end
+
+    def stable?(version)
+      parse(version).prerelease.empty?
+    rescue ArgumentError
+      false
+    end
+
+    def prerelease?(version)
+      !parse(version).prerelease.empty?
+    rescue ArgumentError
+      false
+    end
+
+    def normalize(version)
+      raise ArgumentError, "Invalid Bazel version: #{version.inspect}" unless valid?(version)
+
+      version.split("+", 2).first
+    end
+
+    def parse(version)
+      raise ArgumentError, "Invalid Bazel version: #{version.inspect}" unless version.is_a?(String)
+
+      if version.empty?
+        return ParsedVersion.new(release: [], prerelease: [], empty: true)
+      end
+
+      match = VERSION_REGEX.match(version)
+      raise ArgumentError, "Invalid Bazel version: #{version.inspect}" unless match
+
+      ParsedVersion.new(
+        release: parse_identifiers(match[:release], version),
+        prerelease: match[:prerelease] ? parse_identifiers(match[:prerelease], version) : [],
+        empty: false
+      )
+    end
+
+    def parse_identifiers(value, version)
+      value.split(".", -1).map do |identifier|
+        raise ArgumentError, "Invalid Bazel version: #{version}" if identifier.empty?
+
+        if identifier.match?(/\A[0-9]+\z/)
+          number = identifier.to_i
+          if number > MAX_NUMERIC_IDENTIFIER
+            raise ArgumentError, "Numeric Bazel version identifier is too large: #{identifier}"
+          end
+
+          Identifier.new(numeric: true, number: number, text: identifier)
+        else
+          Identifier.new(numeric: false, number: 0, text: identifier)
+        end
+      end
+    end
+
+    def compare_identifiers(identifiers_a, identifiers_b)
+      [identifiers_a.length, identifiers_b.length].min.times do |index|
+        comparison = compare_identifier(identifiers_a[index], identifiers_b[index])
+        return comparison unless comparison == 0
+      end
+
+      identifiers_a.length <=> identifiers_b.length
+    end
+
+    def compare_identifier(identifier_a, identifier_b)
+      if identifier_a.numeric != identifier_b.numeric
+        return identifier_a.numeric ? -1 : 1
+      end
+
+      if identifier_a.numeric
+        number_comparison = identifier_a.number <=> identifier_b.number
+        return number_comparison unless number_comparison == 0
+      end
+
+      identifier_a.text <=> identifier_b.text
+    end
+  end
+end

data/lib/vers/composer_version.rb

@@ -0,0 +1,117 @@
+# frozen_string_literal: true
+
+require_relative "version_comparison"
+
+module Vers
+  module ComposerVersion
+    extend self
+
+    PATTERN = /\Av?([0-9]+(?:\.[0-9]+){0,3})(?:[-._]?([a-z]+)(?:[.-]?([0-9]+(?:[.-][0-9]+)*))?)?(?:\+\S+)?\z/i
+    NUMERIC_BRANCH_PATTERN = /\Av?\d+(?:\.\d+)*\.x-dev\z/i
+    Parsed = Data.define(:core, :stability, :number)
+
+    STABILITIES = {
+      "dev" => 0,
+      "a" => 1,
+      "alpha" => 1,
+      "b" => 2,
+      "beta" => 2,
+      "rc" => 3,
+      "stable" => 4,
+      "p" => 5,
+      "pl" => 5,
+      "patch" => 5
+    }.freeze
+
+    def compare(left, right)
+      parsed_left = parse(left)
+      parsed_right = parse(right)
+      left_branch = branch?(left)
+      right_branch = branch?(right)
+
+      return -1 if left_branch && !right_branch
+      return 1 if !left_branch && right_branch
+      return left.downcase <=> right.downcase unless parsed_left && parsed_right
+
+      parsed_left.core.zip(parsed_right.core).each do |left_part, right_part|
+        comparison = VersionComparison.compare_numbers(left_part, right_part)
+        return comparison unless comparison.zero?
+      end
+
+      comparison = parsed_left.stability <=> parsed_right.stability
+      return comparison unless comparison.zero?
+
+      compare_numbers(parsed_left.number, parsed_right.number)
+    end
+
+    def parse(value)
+      match = PATTERN.match(value.to_s.strip)
+      return nil unless match
+
+      core = match[1].split(".")
+      core << "0" while core.length < 4
+      qualifier = match[2]&.downcase
+      stability = qualifier ? STABILITIES[qualifier] : 4
+      return nil unless stability
+
+      Parsed.new(core.freeze, stability, match[3].to_s)
+    end
+
+    def branch?(value)
+      string = value.to_s.strip
+      (string.downcase.start_with?("dev-") && string.length > 4) || string.match?(NUMERIC_BRANCH_PATTERN)
+    end
+
+    def valid?(value)
+      string = value.to_s.strip
+      !string.empty? && !string.match?(/[[:space:]]/) && (!parse(string).nil? || branch?(string))
+    end
+
+    def normalize(value, implicit_stability: nil)
+      string = value.to_s.strip
+      return string if branch?(string)
+
+      match = PATTERN.match(string.sub(/\Av(?=\d)/i, ""))
+      raise ArgumentError, "Invalid Composer version: #{value}" unless match
+
+      core = match[1].split(".").map { |part| VersionComparison.normalize_number(part) }
+      core << "0" while core.length < 3
+      qualifier = match[2]&.downcase || implicit_stability
+      qualifier = {"a" => "alpha", "b" => "beta", "rc" => "RC", "p" => "patch", "pl" => "patch"}.fetch(qualifier, qualifier)
+      return core.join(".") if qualifier.nil? || qualifier == "stable"
+
+      "#{core.join(".")}-#{qualifier}#{match[3]}"
+    end
+
+    def release_parts(value)
+      match = PATTERN.match(value.to_s.strip.sub(/\Av(?=\d)/i, ""))
+      return nil unless match
+
+      match[1].split(".")
+    end
+
+    def explicit_stability?(value)
+      match = PATTERN.match(value.to_s.strip.sub(/\Av(?=\d)/i, ""))
+      match && !match[2].nil?
+    end
+
+    def prerelease?(value)
+      return true if branch?(value)
+
+      parsed = parse(value)
+      parsed && parsed.stability < STABILITIES.fetch("stable")
+    end
+
+    def compare_numbers(left, right)
+      left_parts = left.split(/[.-]/)
+      right_parts = right.split(/[.-]/)
+
+      [left_parts.length, right_parts.length].max.times do |index|
+        comparison = VersionComparison.compare_numbers(left_parts[index], right_parts[index])
+        return comparison unless comparison.zero?
+      end
+
+      0
+    end
+  end
+end

data/lib/vers/conan_version.rb

@@ -0,0 +1,87 @@
+# frozen_string_literal: true
+
+require_relative "version_comparison"
+
+module Vers
+  module ConanVersion
+    extend self
+
+    def compare(left, right)
+      left_main, left_pre, left_build = split(left)
+      right_main, right_pre, right_build = split(right)
+
+      comparison = compare_main(left_main, right_main)
+      return comparison unless comparison.zero?
+
+      comparison = compare_optional(left_pre, right_pre, prerelease: true)
+      return comparison unless comparison.zero?
+
+      compare_optional(left_build, right_build, prerelease: false)
+    end
+
+    def split(value)
+      main = value.to_s
+      build = nil
+      prerelease = nil
+
+      separator = main.rindex("+")
+      if separator
+        build = main[(separator + 1)..]
+        main = main[0...separator]
+      end
+
+      separator = main.rindex("-")
+      if separator
+        prerelease = main[(separator + 1)..]
+        main = main[0...separator]
+      end
+
+      [main, prerelease, build]
+    end
+
+    def valid?(value)
+      string = value.to_s.strip
+      !string.empty? && !string.match?(/[[:space:]]/)
+    end
+
+    def normalize(value)
+      value.to_s.strip
+    end
+
+    def prerelease?(value)
+      !split(value.to_s.strip)[1].nil?
+    end
+
+    def compare_main(left, right)
+      left_parts = significant_parts(left)
+      right_parts = significant_parts(right)
+
+      left_parts.zip(right_parts).each do |left_part, right_part|
+        break unless left_part && right_part
+
+        comparison = if VersionComparison.numeric?(left_part) && VersionComparison.numeric?(right_part)
+                       VersionComparison.compare_numbers(left_part, right_part)
+                     else
+                       left_part <=> right_part
+                     end
+        return comparison unless comparison.zero?
+      end
+
+      left_parts.length <=> right_parts.length
+    end
+
+    def significant_parts(value)
+      parts = value.split(".", -1)
+      parts.pop while parts.last && VersionComparison.numeric?(parts.last) && VersionComparison.compare_numbers(parts.last, "0").zero?
+      parts
+    end
+
+    def compare_optional(left, right, prerelease:)
+      return 0 if left.nil? && right.nil?
+      return prerelease ? 1 : -1 if left.nil?
+      return prerelease ? -1 : 1 if right.nil?
+
+      compare(left, right)
+    end
+  end
+end

data/lib/vers/constraint.rb

@@ -131,8 +131,12 @@ module Vers
     # @param version_string [String] The version to check
     # @return [Boolean] true if the version satisfies the constraint
     #
-    def satisfies?(version_string)
-      comparison = Version.compare(version_string, version)
+    def satisfies?(version_string, scheme: nil)
+      comparison = if scheme
+                     Version.compare_with_scheme(version_string, version, scheme)
+                   else
+                     Version.compare(version_string, version)
+                   end
       
       case operator
       when "="
@@ -167,4 +171,4 @@ module Vers
       [operator, version].hash
     end
   end
-end
+end