vers 1.3.1 → 2.0.0

data/lib/vers/parser.rb

@@ -17,21 +17,21 @@ module Vers
   #   range.contains?("1.5.0")  # => true
   #
   class Parser
-    # Regex for parsing vers URI format
-    VERS_URI_REGEX = /\Avers:([^\/]+)\/(.+)\z/
-    
-    # Pre-compiled regex patterns for common npm patterns
-    NPM_CARET_REGEX = /\A\^(.+)\z/
-    NPM_TILDE_REGEX = /\A~(.+)\z/
-    NPM_HYPHEN_REGEX = /\A(.+?)\s+-\s+(.+)\z/
-    NPM_X_RANGE_MAJOR_REGEX = /\A(\d+)\.x\z/
-    NPM_X_RANGE_MINOR_REGEX = /\A(\d+)\.(\d+)\.x\z/
+    NGINX_RANGE_REGEX = /\A\d+(?:\.\d+)+-\d+(?:\.\d+)+\z/
     OPERATOR_PREFIX_REGEX = /\A[><=!]+/
-    
-    # Cache for parsed ranges to improve performance
-    @@parser_cache = {}
-    @@cache_size_limit = 500
-
+    PUB_VERSION_PREFIX_REGEX = /\A[0-9]+\.[0-9]+\.[0-9]+(?:-[0-9A-Za-z-]+(?:\.[0-9A-Za-z-]+)*)?(?:\+[0-9A-Za-z-]+(?:\.[0-9A-Za-z-]+)*)?/
+    SEMVER_OUTPUT_SCHEMES = %w[npm cargo nuget composer pub].freeze
+    VERS_META_ENCODINGS = {
+      "%" => "%25",
+      "|" => "%7C",
+      ">" => "%3E",
+      "<" => "%3C",
+      "=" => "%3D",
+      "!" => "%21",
+      "/" => "%2F",
+      "*" => "%2A",
+      " " => "%20"
+    }.freeze
     # Maximum accepted length for a range string at parse/parse_native
     # entry points. Range strings concatenate multiple constraints so this
     # is set higher than Version::MAX_LENGTH while still bounding
@@ -56,23 +56,39 @@ module Vers
     #
     #   parser = Vers::Parser.new
     #   parser.parse("vers:npm/>=1.2.3|<2.0.0")
-    #   parser.parse("vers:gem/~>1.0")
-    #   parser.parse("vers:pypi/==1.2.3")
+    #   parser.parse_native("~>1.0", "gem")
+    #   parser.parse_native("==1.2.3", "pypi")
     #
-    def parse(vers_string)
+    def parse(vers_string, require_canonical_order: false)
       validate_input_length!(vers_string)
 
-      if vers_string == "*"
-        return VersionRange.unbounded
+      return VersionRange.unbounded if vers_string == "*"
+      unless vers_string.is_a?(String) && vers_string.start_with?("vers:")
+        raise ArgumentError, "Invalid vers URI format: #{vers_string}"
+      end
+      if vers_string.match?(/[ \t\r\n]/)
+        raise ArgumentError, "non-canonical VERS: whitespace is not permitted"
       end
 
-      match = vers_string.match(VERS_URI_REGEX)
-      raise ArgumentError, "Invalid vers URI format: #{vers_string}" unless match
+      remainder = vers_string.delete_prefix("vers:")
+      slash = remainder.index("/")
+      unless slash && slash.positive?
+        raise ArgumentError, "Invalid vers URI format: #{vers_string}"
+      end
 
-      scheme = match[1]
-      constraints_string = match[2]
+      raw_scheme = remainder[...slash]
+      if raw_scheme != raw_scheme.downcase
+        raise ArgumentError, "non-canonical VERS: type must be lowercase"
+      end
+      scheme = Scheme.canonical(raw_scheme)
+      constraints_string = remainder[(slash + 1)..]
+      if constraints_string.empty? || constraints_string == "*"
+        return VersionRange.unbounded(scheme: scheme)
+      end
 
-      parse_constraints(constraints_string, scheme)
+      validate_vers_constraints!(constraints_string, scheme, require_canonical_order)
+
+      parse_constraints(constraints_string, scheme, decode_versions: true)
     end
 
     ##
@@ -92,31 +108,43 @@ module Vers
     def parse_native(range_string, scheme)
       validate_input_length!(range_string)
 
-      case scheme
+      canonical_scheme = Scheme.canonical(scheme)
+      range = case canonical_scheme
       when "npm"
-        parse_npm_range(range_string)
-      when "gem", "rubygems"
+        parse_npm_range(range_string, scheme: "npm")
+      when "gem"
         parse_gem_range(range_string)
       when "pypi"
         parse_pypi_range(range_string)
+      when "composer"
+        parse_composer_range(range_string)
+      when "pub"
+        parse_pub_range(range_string)
+      when "conan"
+        parse_conan_range(range_string)
+      when "nginx"
+        parse_nginx_range(range_string)
+      when "openssl"
+        parse_openssl_range(range_string)
       when "maven"
         parse_maven_range(range_string)
       when "cargo"
-        parse_npm_range(range_string)
+        parse_npm_range(range_string, scheme: "cargo")
       when "nuget"
         parse_nuget_range(range_string)
-      when "hex", "elixir"
+      when "hex"
         parse_hex_range(range_string)
-      when "go", "golang"
+      when "go"
         parse_go_range(range_string)
-      when "deb", "debian"
+      when "deb"
         parse_debian_range(range_string)
       when "rpm"
         parse_rpm_range(range_string)
       else
         # Fall back to generic constraint parsing
-        parse_constraints(range_string, scheme)
+        parse_constraints(range_string, canonical_scheme)
       end
+      range.with_scheme(canonical_scheme)
     end
 
     ##
@@ -127,41 +155,61 @@ module Vers
     # @return [String] The vers URI string
     #
     def to_vers_string(version_range, scheme)
-      return "vers:#{scheme}/*" if version_range.unbounded?
-      return "vers:#{scheme}/" if version_range.empty?
+      canonical_scheme = Scheme.canonical(scheme)
+      if version_range.scheme && canonical_scheme != version_range.scheme
+        raise ArgumentError, "Cannot serialize a #{version_range.scheme} range as #{canonical_scheme}"
+      end
 
-      intervals = version_range.raw_constraints || version_range.intervals
+      scheme = canonical_scheme
+      if version_range.unbounded? && (!version_range.raw_constraints || version_range.raw_constraints.empty?)
+        return "vers:#{scheme}/*"
+      end
+      if version_range.empty? && (!version_range.raw_constraints || version_range.raw_constraints.empty?)
+        return "vers:#{scheme}/"
+      end
+
+      intervals = serialization_intervals(version_range, scheme)
       constraints = []
 
       # 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) }
+          version = encode_vers_version(normalize_vers_version(a.max, scheme))
+          constraints << "!=#{version}"
+          sort_constraints!(constraints, scheme)
           return "vers:#{scheme}/#{constraints.join('|')}"
         end
       end
 
       intervals.each do |interval|
+        next if interval.unbounded?
+
         if interval.min == interval.max && interval.min_inclusive && interval.max_inclusive
           # Exact version
-          constraints << interval.min.to_s
+          constraints << encode_vers_version(normalize_vers_version(interval.min.to_s, scheme))
         else
           # Range constraints
           if interval.min
             operator = interval.min_inclusive ? ">=" : ">"
-            constraints << "#{operator}#{interval.min}"
+            version = encode_vers_version(normalize_vers_version(interval.min, scheme))
+            constraints << "#{operator}#{version}"
           end
 
           if interval.max
             operator = interval.max_inclusive ? "<=" : "<"
-            constraints << "#{operator}#{interval.max}"
+            version = encode_vers_version(normalize_vers_version(interval.max, scheme))
+            constraints << "#{operator}#{version}"
           end
         end
       end
 
-      constraints.sort_by! { |c| sort_key_for_constraint(c) }
+      version_range.exclusions.each do |version|
+        normalized = normalize_vers_version(version, scheme)
+        constraints << "!=#{encode_vers_version(normalized)}"
+      end
+
+      sort_constraints!(constraints, scheme)
 
       "vers:#{scheme}/#{constraints.join('|')}"
     end
@@ -174,13 +222,152 @@ module Vers
       raise ArgumentError, "Range string too long (#{input.length} > #{MAX_INPUT_LENGTH})"
     end
 
-    def sort_key_for_constraint(constraint)
-      version = constraint.sub(OPERATOR_PREFIX_REGEX, '')
-      v = Version.cached_new(version)
-      [v, constraint]
+    def validate_vers_constraints!(constraints, scheme, require_canonical_order)
+      if constraints.start_with?("|")
+        raise ArgumentError, "non-canonical VERS: leading pipe is not permitted"
+      end
+      if constraints.end_with?("|")
+        raise ArgumentError, "non-canonical VERS: trailing pipe is not permitted"
+      end
+      if constraints.include?("||")
+        raise ArgumentError, "non-canonical VERS: consecutive pipes are not permitted"
+      end
+
+      previous = nil
+      previous_raw = nil
+      seen_versions = []
+      constraints.split("|").each do |raw|
+        constraint = Constraint.parse(raw)
+        validate_vers_version!(constraint.version, scheme)
+        decoded_version = decode_vers_version(constraint.version)
+
+        if require_canonical_order
+          if seen_versions.any? { |version| Version.compare_with_scheme(version, decoded_version, scheme).zero? }
+            raise ArgumentError, "non-canonical VERS: duplicate versions are not permitted"
+          end
+          if previous
+            order = Version.compare_with_scheme(previous, decoded_version, scheme)
+            if order.positive? || (order.zero? && previous_raw > raw)
+              raise ArgumentError, "non-canonical VERS: constraints are not sorted by version"
+            end
+          end
+          seen_versions << decoded_version
+        end
+
+        previous = decoded_version
+        previous_raw = raw
+      end
+    end
+
+    def validate_vers_version!(version, scheme)
+      index = 0
+      while index < version.bytesize
+        unless version.getbyte(index) == 37
+          index += 1
+          next
+        end
+
+        first = version.getbyte(index + 1)
+        second = version.getbyte(index + 2)
+        unless ascii_hex?(first) && ascii_hex?(second)
+          raise ArgumentError, "non-canonical VERS: invalid percent-encoding in version"
+        end
+        if lowercase_ascii_hex?(first) || lowercase_ascii_hex?(second)
+          raise ArgumentError, "non-canonical VERS: percent-encoding in version is not canonical"
+        end
+
+        index += 3
+      end
+
+      if version.match?(/[><=!*\/]/)
+        raise ArgumentError, "non-canonical VERS: reserved characters in version must be percent-encoded"
+      end
+
+      return unless scheme == "datetime"
+      if version.include?("%3A")
+        raise ArgumentError, "non-canonical VERS: datetime time colons must be unencoded"
+      end
+
+      decoded = decode_vers_version(version)
+      if (decoded.length > 10 && decoded[10] == "t") || decoded.end_with?("z")
+        raise ArgumentError, "non-canonical VERS: datetime must use uppercase T and Z"
+      end
+    end
+
+    def ascii_hex?(byte)
+      byte && ((48..57).cover?(byte) || (65..70).cover?(byte) || lowercase_ascii_hex?(byte))
+    end
+
+    def lowercase_ascii_hex?(byte)
+      byte && (97..102).cover?(byte)
+    end
+
+    def sort_constraints!(constraints, scheme)
+      constraints.sort! do |left, right|
+        left_version = decode_vers_version(left.sub(OPERATOR_PREFIX_REGEX, ""))
+        right_version = decode_vers_version(right.sub(OPERATOR_PREFIX_REGEX, ""))
+        comparison = Version.compare_with_scheme(left_version, right_version, scheme)
+        comparison.zero? ? left <=> right : comparison
+      end
+    end
+
+    def serialization_intervals(version_range, scheme)
+      raw_constraints = version_range.raw_constraints
+      return version_range.intervals unless raw_constraints
+      return raw_constraints unless %w[npm cargo].include?(scheme)
+      return raw_constraints if version_range.empty?
+
+      grouped = intersect_consecutive_intervals(raw_constraints, scheme)
+      raw_range = VersionRange.new(grouped, scheme: scheme)
+      equivalent_intervals?(raw_range.intervals, version_range.intervals, scheme) ? raw_constraints : version_range.intervals
+    end
+
+    def equivalent_intervals?(left, right, scheme)
+      return false unless left.length == right.length
+
+      left.zip(right).all? do |left_interval, right_interval|
+        left_interval.min_inclusive == right_interval.min_inclusive &&
+          left_interval.max_inclusive == right_interval.max_inclusive &&
+          equivalent_bound?(left_interval.min, right_interval.min, scheme) &&
+          equivalent_bound?(left_interval.max, right_interval.max, scheme)
+      end
+    end
+
+    def equivalent_bound?(left, right, scheme)
+      return true if left.nil? && right.nil?
+      return false if left.nil? || right.nil?
+
+      Version.compare_for_range(left, right, scheme).zero?
     end
 
-    def parse_constraints(constraints_string, scheme)
+    def normalize_vers_version(version, scheme)
+      canonical_scheme = Scheme.canonical(scheme)
+      if %w[npm cargo].include?(canonical_scheme) && SemverVersion.valid?(version)
+        return SemverVersion.normalize(version)
+      end
+
+      return version if version.include?("-")
+      return version unless SEMVER_OUTPUT_SCHEMES.include?(canonical_scheme)
+      return version unless SemverVersion.valid?(version)
+
+      case version.count(".")
+      when 0
+        "#{version}.0.0"
+      when 1
+        "#{version}.0"
+      else
+        version
+      end
+    end
+
+    def encode_vers_version(version)
+      version.gsub(/[\%|><=!\/* ]/, VERS_META_ENCODINGS)
+    end
+
+    def parse_constraints(constraints_string, scheme, decode_versions: false)
+      canonical_scheme = Scheme.canonical(scheme)
+      return VersionRange.unbounded(scheme: canonical_scheme) if constraints_string == "*"
+
       # Limit constraint count to bound the O(n^2 log n) exclusion loop
       # below: each != splits an interval and reconstructs the range.
       constraint_strings = constraints_string.split(/[|,]/, MAX_CONSTRAINTS + 1)
@@ -189,10 +376,13 @@ module Vers
       end
       intervals = []
       exclusions = []
-      interval_scheme = %w[maven nuget].include?(scheme) ? scheme : nil
+      interval_scheme = canonical_scheme
 
       constraint_strings.each do |constraint_string|
         constraint = Constraint.parse(constraint_string.strip)
+        if decode_versions
+          constraint = Constraint.new(constraint.operator, decode_vers_version(constraint.version))
+        end
 
         if constraint.exclusion?
           exclusions << constraint.version
@@ -202,189 +392,622 @@ module Vers
         end
       end
 
+      grouped_intervals = intersect_consecutive_intervals(intervals, interval_scheme)
+
       # Start with the union of all positive constraints, or unbounded if only exclusions
-      range = if intervals.any?
-                VersionRange.new(intervals, scheme: interval_scheme)
+      range = if grouped_intervals.any?
+                VersionRange.new(
+                  grouped_intervals,
+                  raw_constraints: intervals,
+                  scheme: interval_scheme,
+                  exclusions: exclusions
+                )
               elsif exclusions.any?
-                VersionRange.unbounded
+                VersionRange.new(
+                  [Interval.unbounded(scheme: interval_scheme)],
+                  raw_constraints: [],
+                  scheme: interval_scheme,
+                  exclusions: exclusions
+                )
               else
                 VersionRange.new([], scheme: interval_scheme)
               end
 
-      # Apply exclusions
-      exclusions.each do |version|
-        range = range.exclude(version)
+      range
+    end
+
+    def intersect_consecutive_intervals(intervals, scheme)
+      grouped = []
+      index = 0
+
+      while index < intervals.length
+        current = intervals.fetch(index)
+        following = intervals[index + 1]
+        opposite_bounds = following &&
+          ((current.min && !current.max && following.max && !following.min) ||
+           (current.max && !current.min && following.min && !following.max))
+
+        if opposite_bounds
+          intersection = current.intersect(following)
+          unless intersection.empty?
+            grouped << intersection
+            index += 2
+            next
+          end
+        end
+
+        grouped << current.with_scheme(scheme)
+        index += 1
       end
 
-      range
+      grouped
+    end
+
+    def decode_vers_version(version)
+      version.gsub(/%([0-9A-Fa-f]{2})/) { [$1.to_i(16)].pack("C") }
+    end
+
+    def parse_composer_range(range_string)
+      constraint = range_string.to_s.strip
+      return VersionRange.unbounded(scheme: "composer") if %w[* x X @dev].include?(constraint)
+
+      parts = constraint.split(/\s*\|\|?\s*/)
+      raise ArgumentError, "Invalid Composer range: #{range_string}" if parts.any?(&:empty?)
+
+      ranges = parts.map { |part| parse_composer_conjunction(part) }
+      ranges.reduce { |combined, range| combined.union(range) }
+    end
+
+    def parse_composer_conjunction(constraint)
+      value = constraint.strip.sub(/\s+as\s+.+\z/i, "")
+      if (match = /\A(\S+)\s+-\s+(\S+)\z/.match(value))
+        return parse_composer_hyphen_range(match[1], match[2])
+      end
+
+      parts = value.tr(",", " ").split
+      ranges = parts.map { |part| parse_composer_constraint(part) }
+      ranges.reduce { |combined, range| combined.intersect(range) }
+    end
+
+    def parse_composer_constraint(constraint)
+      return VersionRange.unbounded(scheme: "composer") if constraint == "@dev"
+
+      value, stability = constraint.split("@", 2)
+      return VersionRange.unbounded(scheme: "composer") if value.empty?
+      return parse_composer_wildcard(value) if composer_wildcard?(value)
+      return parse_composer_caret(value.delete_prefix("^")) if value.start_with?("^")
+      return parse_composer_tilde(value.delete_prefix("~")) if value.start_with?("~")
+      return composer_exact_range(value) if ComposerVersion.branch?(value)
+
+      operator = value[/\A(?:==|<>|!=|>=|<=|>|<|=)/] || "="
+      version = value.delete_prefix(operator)
+      operator = "=" if operator == "=="
+      operator = "!=" if operator == "<>"
+      implicit = operator == "=" || operator == "!=" ? nil : "dev"
+      normalized = ComposerVersion.normalize(version, implicit_stability: stability || implicit)
+
+      return composer_exclusion_range(normalized) if operator == "!="
+      return composer_exact_range(normalized) if operator == "="
+
+      composer_interval_range(Constraint.new(operator, normalized).to_interval(scheme: "composer"))
+    end
+
+    def parse_composer_caret(version)
+      parts = ComposerVersion.release_parts(version)
+      raise ArgumentError, "Invalid Composer caret version: #{version}" unless parts
+
+      bump = 0
+      if VersionComparison.compare_numbers(parts[0], "0").zero? && parts.length > 1
+        bump = 1
+        if VersionComparison.compare_numbers(parts[1], "0").zero? && parts.length > 2
+          bump = 2
+        end
+      end
+
+      lower = ComposerVersion.normalize(version, implicit_stability: "dev")
+      upper = increment_composer_release(parts, bump)
+      composer_interval_range(Interval.new(min: lower, max: upper, min_inclusive: true, max_inclusive: false, scheme: "composer"))
+    end
+
+    def parse_composer_tilde(version)
+      parts = ComposerVersion.release_parts(version)
+      raise ArgumentError, "Invalid Composer tilde version: #{version}" unless parts
+
+      bump = parts.length > 2 ? parts.length - 2 : 0
+      lower = ComposerVersion.normalize(version, implicit_stability: "dev")
+      upper = increment_composer_release(parts, bump)
+      composer_interval_range(Interval.new(min: lower, max: upper, min_inclusive: true, max_inclusive: false, scheme: "composer"))
+    end
+
+    def parse_composer_wildcard(value)
+      return VersionRange.unbounded(scheme: "composer") if %w[* x X].include?(value)
+
+      segments = value.sub(/\Av(?=\d)/i, "").split(".")
+      prefix = []
+      wildcard = false
+      segments.each do |segment|
+        if segment == "*" || segment.casecmp?("x")
+          wildcard = true
+        elsif wildcard || !VersionComparison.numeric?(segment)
+          raise ArgumentError, "Invalid Composer wildcard: #{value}"
+        else
+          prefix << segment
+        end
+      end
+      raise ArgumentError, "Invalid Composer wildcard: #{value}" unless wildcard
+      return VersionRange.unbounded(scheme: "composer") if prefix.empty?
+
+      lower_parts = prefix.map { |part| VersionComparison.normalize_number(part) }
+      lower_parts << "0" while lower_parts.length < 3
+      lower = "#{lower_parts.join(".")}-dev"
+      upper = increment_composer_release(prefix, prefix.length - 1)
+      composer_interval_range(Interval.new(min: lower, max: upper, min_inclusive: true, max_inclusive: false, scheme: "composer"))
+    end
+
+    def parse_composer_hyphen_range(lower, upper)
+      lower_parts = ComposerVersion.release_parts(lower)
+      upper_parts = ComposerVersion.release_parts(upper)
+      raise ArgumentError, "Invalid Composer hyphen range: #{lower} - #{upper}" unless lower_parts && upper_parts
+
+      minimum = ComposerVersion.normalize(lower, implicit_stability: "dev")
+      if upper_parts.length < 3 && !ComposerVersion.explicit_stability?(upper)
+        maximum = increment_composer_release(upper_parts, upper_parts.length - 1)
+        interval = Interval.new(min: minimum, max: maximum, min_inclusive: true, max_inclusive: false, scheme: "composer")
+      else
+        maximum = ComposerVersion.normalize(upper)
+        interval = Interval.new(min: minimum, max: maximum, min_inclusive: true, max_inclusive: true, scheme: "composer")
+      end
+      composer_interval_range(interval)
+    end
+
+    def increment_composer_release(parts, index)
+      length = [parts.length, 3].max
+      incremented = Array.new(length, "0")
+      parts.each_with_index { |part, part_index| incremented[part_index] = VersionComparison.normalize_number(part) }
+      incremented[index] = (incremented[index].to_i + 1).to_s
+      ((index + 1)...length).each { |part_index| incremented[part_index] = "0" }
+      "#{incremented.join(".")}-dev"
+    end
+
+    def composer_wildcard?(value)
+      value.split(".").any? { |part| part == "*" || part.casecmp?("x") }
+    end
+
+    def composer_interval_range(interval)
+      VersionRange.new([interval], raw_constraints: [interval], scheme: "composer")
+    end
+
+    def composer_exact_range(version)
+      interval = Interval.exact(ComposerVersion.branch?(version) ? version : ComposerVersion.normalize(version), scheme: "composer")
+      composer_interval_range(interval)
+    end
+
+    def composer_exclusion_range(version)
+      VersionRange.new(
+        [Interval.unbounded(scheme: "composer")],
+        raw_constraints: [],
+        scheme: "composer",
+        exclusions: [version]
+      )
+    end
+
+    def parse_pub_range(range_string)
+      constraint = range_string.to_s.strip
+      return VersionRange.unbounded(scheme: "pub") if constraint == "any"
+      raise ArgumentError, "Empty Pub range" if constraint.empty?
+      raise ArgumentError, "Unsupported Pub range: #{range_string}" if constraint.match?(/[,|*]/) || constraint.include?("!=")
+      return parse_pub_caret(constraint.delete_prefix("^")) if constraint.start_with?("^")
+
+      ranges = tokenize_pub_constraints(constraint).map { |part| parse_pub_constraint(part) }
+      adjust_pub_upper_bounds(ranges.reduce { |combined, range| combined.intersect(range) })
+    end
+
+    def tokenize_pub_constraints(constraint)
+      remaining = constraint.strip
+      tokens = []
+
+      until remaining.empty?
+        operator = remaining[/\A(?:>=|<=|>|<)/].to_s
+        remaining = remaining.delete_prefix(operator).lstrip
+        match = PUB_VERSION_PREFIX_REGEX.match(remaining)
+        raise ArgumentError, "Invalid Pub range: #{constraint}" unless match
+
+        tokens << "#{operator}#{match[0]}"
+        remaining = remaining[match[0].length..].to_s.strip
+      end
+
+      tokens
+    end
+
+    def parse_pub_constraint(constraint)
+      operator = constraint[/\A(?:>=|<=|>|<)/].to_s
+      version = constraint.delete_prefix(operator)
+      raise ArgumentError, "Invalid Pub version: #{version}" unless PubVersion.valid?(version)
+
+      interval = if operator.empty?
+                   Interval.exact(version, scheme: "pub")
+                 else
+                   Constraint.new(operator, version).to_interval(scheme: "pub")
+                 end
+      VersionRange.new([interval], raw_constraints: [interval], scheme: "pub")
+    end
+
+    def parse_pub_caret(version)
+      parsed = PubVersion.parse(version)
+      raise ArgumentError, "Invalid Pub caret version: #{version}" unless parsed
+
+      upper = if VersionComparison.compare_numbers(parsed.core[0], "0").zero?
+                "0.#{parsed.core[1].to_i + 1}.0-0"
+              else
+                "#{parsed.core[0].to_i + 1}.0.0-0"
+              end
+      interval = Interval.new(min: version, max: upper, min_inclusive: true, max_inclusive: false, scheme: "pub")
+      VersionRange.new([interval], raw_constraints: [interval], scheme: "pub")
+    end
+
+    def adjust_pub_upper_bounds(range)
+      replacements = {}
+      intervals = range.intervals.map do |interval|
+        next interval unless pub_upper_needs_first_prerelease?(interval)
+
+        replacements[interval.max] = "#{interval.max}-0"
+        Interval.new(
+          min: interval.min,
+          max: replacements.fetch(interval.max),
+          min_inclusive: interval.min_inclusive,
+          max_inclusive: interval.max_inclusive,
+          scheme: "pub"
+        )
+      end
+      raw_constraints = (range.raw_constraints || range.intervals).map do |interval|
+        replacement = !interval.max_inclusive && replacements[interval.max]
+        next interval unless replacement
+
+        Interval.new(
+          min: interval.min,
+          max: replacement,
+          min_inclusive: interval.min_inclusive,
+          max_inclusive: interval.max_inclusive,
+          scheme: "pub"
+        )
+      end
+      VersionRange.new(intervals, raw_constraints: raw_constraints, scheme: "pub", exclusions: range.exclusions)
+    end
+
+    def pub_upper_needs_first_prerelease?(interval)
+      return false unless interval.max && !interval.max_inclusive && PubVersion.valid?(interval.max)
+
+      maximum = PubVersion.parse(interval.max)
+      return false unless maximum.prerelease.empty? && maximum.build.empty?
+      return true unless interval.min && PubVersion.valid?(interval.min)
+
+      minimum = PubVersion.parse(interval.min)
+      return true if minimum.prerelease.empty?
+
+      !minimum.core.zip(maximum.core).all? do |minimum_part, maximum_part|
+        VersionComparison.compare_numbers(minimum_part, maximum_part).zero?
+      end
+    end
+
+    def parse_conan_range(range_string)
+      constraint = range_string.to_s.strip.split(",", 2).first.to_s.strip
+      return VersionRange.empty(scheme: "conan") if constraint.empty?
+
+      if %w[* *-].include?(constraint)
+        interval = Interval.greater_than("0.0.0", inclusive: true, scheme: "conan")
+        return VersionRange.new([interval], raw_constraints: [interval], scheme: "conan")
+      end
+
+      if constraint.include?("||")
+        parts = constraint.split("||").map(&:strip)
+        raise ArgumentError, "Invalid Conan range: #{range_string}" if parts.any?(&:empty?)
+
+        return parts.map { |part| parse_conan_range(part) }.reduce { |combined, range| combined.union(range) }
+      end
+
+      if constraint.match?(/\s/)
+        parts = constraint.split
+        return parts.map { |part| parse_conan_range(part) }.reduce { |combined, range| combined.intersect(range) }
+      end
+
+      constraint = constraint.delete_suffix("-")
+      if constraint.start_with?("~", "^")
+        operator = constraint[0]
+        version = constraint[1..]
+        upper = conan_upper_bound(version, operator)
+        interval = Interval.new(
+          min: version,
+          max: upper,
+          min_inclusive: true,
+          max_inclusive: false,
+          scheme: "conan"
+        )
+        return VersionRange.new([interval], raw_constraints: [interval], scheme: "conan")
+      end
+
+      parse_constraints(constraint, "conan")
+    end
+
+    def conan_upper_bound(version, operator)
+      parts = version.split(".")
+      unless parts.any? && parts.all? { |part| VersionComparison.numeric?(part) }
+        raise ArgumentError, "Invalid Conan compatible version: #{version}"
+      end
+
+      index = 0
+      if operator == "~" && parts.length > 1
+        index = 1
+      elsif operator == "^"
+        index += 1 while index < parts.length - 1 && VersionComparison.compare_numbers(parts[index], "0").zero?
+      end
+
+      upper = parts.first(index + 1).map { |part| VersionComparison.normalize_number(part) }
+      upper[index] = (upper[index].to_i + 1).to_s
+      "#{upper.join(".")}-"
+    end
+
+    def parse_openssl_range(range_string)
+      parts = range_string.to_s.split(",", -1).map(&:strip)
+      intervals = parts.map do |version|
+        unless OpenSSLVersion.valid?(version)
+          raise ArgumentError, "Invalid OpenSSL version: #{version}"
+        end
+
+        Interval.exact(version, scheme: "openssl")
+      end
+      VersionRange.new(intervals, raw_constraints: intervals, scheme: "openssl")
+    end
+
+    def parse_nginx_range(range_string)
+      constraint = range_string.to_s.strip
+      if constraint.include?(",")
+        parts = constraint.split(",", -1).map(&:strip)
+        raise ArgumentError, "Invalid Nginx range: #{range_string}" if parts.any?(&:empty?)
+
+        return parts.map { |part| parse_nginx_range(part) }.reduce { |combined, range| combined.union(range) }
+      end
+
+      if constraint.end_with?("+")
+        version = constraint.delete_suffix("+")
+        unless SemverVersion.valid?(version)
+          raise ArgumentError, "Invalid Nginx range: #{range_string}"
+        end
+
+        parts = version.split(".")
+        maximum = if parts.fetch(1).to_i.even?
+                    "#{parts.fetch(0)}.#{parts.fetch(1).to_i + 1}.0"
+                  end
+        interval = Interval.new(
+          min: version,
+          max: maximum,
+          min_inclusive: true,
+          max_inclusive: false,
+          scheme: "nginx"
+        )
+        return VersionRange.new([interval], raw_constraints: [interval], scheme: "nginx")
+      end
+
+      if NGINX_RANGE_REGEX.match?(constraint)
+        minimum, maximum = constraint.split("-", 2)
+        unless SemverVersion.valid?(minimum) && SemverVersion.valid?(maximum)
+          raise ArgumentError, "Invalid Nginx range: #{range_string}"
+        end
+
+        interval = Interval.new(
+          min: minimum,
+          max: maximum,
+          min_inclusive: true,
+          max_inclusive: true,
+          scheme: "nginx"
+        )
+        return VersionRange.new([interval], raw_constraints: [interval], scheme: "nginx")
+      end
+
+      parse_constraints(constraint, "nginx")
     end
 
     # NPM range parsing (^, ~, -, ||, etc.)
-    def parse_npm_range(range_string)
-      # Handle empty string as unbounded
-      if range_string.nil? || range_string.strip.empty?
-        return VersionRange.unbounded
-      end
-      
-      # Handle || (OR) operator
-      if range_string.include?('||')
-        or_parts = range_string.split('||', MAX_CONSTRAINTS + 1).map(&:strip)
+    def parse_npm_range(range_string, scheme: "npm")
+      constraint = range_string.to_s.strip
+      return VersionRange.unbounded(scheme: scheme) if constraint.empty? || %w[* x X].include?(constraint)
+
+      if constraint.include?("||")
+        or_parts = constraint.split("||", MAX_CONSTRAINTS + 1).map(&:strip)
         if or_parts.length > MAX_CONSTRAINTS
           raise ArgumentError, "Too many || clauses (> #{MAX_CONSTRAINTS})"
         end
-        ranges = or_parts.map { |part| parse_npm_range(part) }
-        return ranges.reduce { |acc, range| acc.union(range) }
+        ranges = or_parts.map { |part| parse_npm_range(part, scheme: scheme) }
+        return ranges.reduce { |combined, range| combined.union(range) }
       end
 
-      # Handle hyphen ranges first (before space splitting)
-      if range_string.match(/^(.+?)\s+-\s+(.+)$/)
-        return parse_npm_single_range(range_string)
+      if constraint.include?(" - ")
+        lower, upper = constraint.split(" - ", 2).map(&:strip)
+        return parse_npm_hyphen_range(lower, upper, scheme: scheme)
       end
 
-      # Handle space-separated AND constraints
-      and_parts = range_string.split(/\s+/).reject(&:empty?)
-      # 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
+      if constraint.match?(/[ \t\r\n]/)
+        tokens = constraint.split
+        merged = []
+        tokens.each do |token|
+          if merged.last&.match?(/\A(?:>=|<=|!=|>|<|=|~>|~|\^)\z/)
+            merged[-1] = "#{merged.last}#{token}"
+          else
+            merged << token
+          end
         end
+        ranges = merged.map { |part| parse_npm_single_range(part, scheme: scheme) }
+        return ranges.reduce { |combined, range| combined.intersect(range) }
+      end
+
+      parse_npm_single_range(constraint, scheme: scheme)
+    end
+
+    def parse_npm_single_range(range_string, scheme: "npm")
+      constraint = range_string.to_s.strip
+      return parse_caret_range(constraint.delete_prefix("^").strip, scheme: scheme) if constraint.start_with?("^")
+      return parse_tilde_range(constraint.delete_prefix("~>").strip, scheme: scheme) if constraint.start_with?("~>")
+      return parse_tilde_range(constraint.delete_prefix("~").strip, scheme: scheme) if constraint.start_with?("~")
+
+      operator, version = extract_npm_operator(constraint)
+      if constraint.end_with?(".x", ".X", ".*") || partial_npm_version?(version)
+        return parse_npm_partial_range(version, operator, scheme: scheme)
+      end
+
+      parsed = Constraint.parse(constraint)
+      unless NpmVersion.valid?(parsed.version)
+        raise ArgumentError, "Invalid NPM range format: #{range_string}"
       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) }
+
+      if parsed.exclusion?
+        VersionRange.unbounded(scheme: scheme).exclude(parsed.version)
       else
-        ranges.reduce { |acc, range| acc.intersect(range) }
-      end
-    end
-
-    def parse_npm_single_range(range_string)
-      cache_key = "npm:#{range_string}"
-      return @@parser_cache[cache_key] if @@parser_cache.key?(cache_key)
-
-      if @@parser_cache.size >= @@cache_size_limit
-        keys = @@parser_cache.keys
-        keys.first(keys.size / 2).each { |k| @@parser_cache.delete(k) }
-      end
-      
-      result = case range_string
-               when NPM_CARET_REGEX
-                 # Caret range: ^1.2.3 := >=1.2.3 <2.0.0
-                 version = $1
-                 parse_caret_range(version)
-               when NPM_TILDE_REGEX
-                 # Tilde range: ~1.2.3 := >=1.2.3 <1.3.0
-                 version = $1
-                 parse_tilde_range(version)
-               when NPM_HYPHEN_REGEX
-                 # Hyphen range: 1.2.3 - 2.3.4 := >=1.2.3 <=2.3.4
-                 from_version = $1.strip
-                 to_version = $2.strip
-                 VersionRange.new([
-                   Interval.new(min: from_version, max: to_version, min_inclusive: true, max_inclusive: true)
-                 ])
-               when "*", "x", "X"
-                 VersionRange.unbounded
-               when NPM_X_RANGE_MAJOR_REGEX
-                 # X-range like "1.x" := >=1.0.0 <2.0.0
-                 major = $1.to_i
-                 VersionRange.new([
-                   Interval.new(min: "#{major}.0.0", max: "#{major + 1}.0.0", min_inclusive: true, max_inclusive: false)
-                 ])
-               when NPM_X_RANGE_MINOR_REGEX
-                 # X-range like "1.2.x" := >=1.2.0 <1.3.0
-                 major = $1.to_i
-                 minor = $2.to_i
-                 VersionRange.new([
-                   Interval.new(min: "#{major}.#{minor}.0", max: "#{major}.#{minor + 1}.0", min_inclusive: true, max_inclusive: false)
-                 ])
-               when /^(blerg|git\+|https?:\/\/)/
-                 # 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)
+        interval = parsed.to_interval(scheme: scheme)
+        VersionRange.new([interval], scheme: scheme)
+      end
+    end
+
+    def parse_caret_range(version, scheme: "npm")
+      return VersionRange.unbounded(scheme: scheme) if version.empty? || %w[* x X].include?(version)
+      return parse_npm_partial_range(version, "", scheme: scheme) if version.end_with?(".x", ".X", ".*")
+
+      parsed = SemverVersion.parse(version)
+      raise ArgumentError, "Invalid NPM caret version: #{version}" unless parsed && NpmVersion.valid?(version)
+
+      base = version.split("+", 2).first.split("-", 2).first.delete_prefix("v").delete_prefix("V")
+      segments = base.count(".") + 1
+      major, minor, patch = parsed.core.map(&:to_i)
+      upper = if segments == 1 || major.positive?
+                "#{major + 1}.0.0"
+              elsif segments == 2 || minor.positive?
+                "0.#{minor + 1}.0"
+              else
+                "0.0.#{patch + 1}"
+              end
+      interval = Interval.new(min: version, max: upper, min_inclusive: true, max_inclusive: false, scheme: scheme)
+      VersionRange.new([interval], scheme: scheme)
+    end
+
+    def parse_tilde_range(version, scheme: "npm")
+      return VersionRange.unbounded(scheme: scheme) if version.empty? || %w[* x X].include?(version)
+      return parse_npm_partial_range(version, "", scheme: scheme) if version.end_with?(".x", ".X", ".*")
+
+      parsed = SemverVersion.parse(version)
+      raise ArgumentError, "Invalid NPM tilde version: #{version}" unless parsed && NpmVersion.valid?(version)
+
+      base = version.split("+", 2).first.split("-", 2).first.delete_prefix("v").delete_prefix("V")
+      segments = base.count(".") + 1
+      major, minor, patch = parsed.core.map(&:to_i)
+      upper = if segments >= 2
+                "#{major}.#{minor + 1}.0"
+              else
+                "#{major + 1}.0.0"
+              end
+      interval = Interval.new(min: version, max: upper, min_inclusive: true, max_inclusive: false, scheme: scheme)
+      raw_constraints = if parsed.prerelease.empty?
+                          nil
+                        else
+                          base_version = "#{major}.#{minor}.#{patch}"
+                          next_patch = "#{major}.#{minor}.#{patch + 1}"
+                          [
+                            Interval.new(min: version, max: base_version, min_inclusive: true, max_inclusive: false, scheme: scheme),
+                            Interval.new(min: base_version, max: next_patch, min_inclusive: true, max_inclusive: false, scheme: scheme)
+                          ]
+                        end
+      VersionRange.new([interval], raw_constraints: raw_constraints, scheme: scheme)
+    end
+
+    def parse_npm_partial_range(version, operator, scheme: "npm")
+      lower, upper = npm_partial_bounds(version)
+      return VersionRange.unbounded(scheme: scheme) unless lower
+
+      interval = case operator
+                 when "", "="
+                   Interval.new(min: lower, max: upper, min_inclusive: true, max_inclusive: false, scheme: scheme)
+                 when ">="
+                   Interval.greater_than(lower, inclusive: true, scheme: scheme)
+                 when ">"
+                   Interval.greater_than(upper, inclusive: true, scheme: scheme)
+                 when "<="
+                   Interval.less_than(upper, scheme: scheme)
+                 when "<"
+                   Interval.less_than(lower, scheme: scheme)
                  else
-                   VersionRange.new([constraint.to_interval])
+                   raise ArgumentError, "Invalid operator for NPM partial range: #{operator}"
                  end
-               end
-      
-      @@parser_cache[cache_key] = result
-      result
+
+      VersionRange.new([interval], raw_constraints: [interval], scheme: scheme)
     end
 
-    def parse_caret_range(version)
-      v = Version.cached_new(version)
-      upper_version = if v.major > 0
-                        # ^1.2.3 := >=1.2.3 <2.0.0
-                        "#{v.major + 1}.0.0"
-                      elsif v.minor && v.minor > 0
-                        # ^0.2.3 := >=0.2.3 <0.3.0
-                        "0.#{v.minor + 1}.0"
-                      else
-                        # ^0.0.3 := >=0.0.3 <0.0.4
-                        "0.0.#{(v.patch || 0) + 1}"
-                      end
+    def npm_partial_bounds(version)
+      constraint = version.to_s.strip
+      return [nil, nil] if constraint.empty? || %w[* x X].include?(constraint)
 
-      VersionRange.new([
-        Interval.new(min: version, max: upper_version, min_inclusive: true, max_inclusive: false)
-      ])
+      segments = constraint.delete_prefix("v").delete_prefix("V").split(".", -1)
+      raise ArgumentError, "Invalid NPM partial version: #{version}" if segments.length > 3
+
+      parts = []
+      wildcard = false
+      segments.each do |segment|
+        if %w[* x X].include?(segment)
+          wildcard = true
+        elsif wildcard || !VersionComparison.numeric?(segment)
+          raise ArgumentError, "Invalid NPM partial version: #{version}"
+        else
+          parts << segment.to_i
+        end
+      end
+      return [nil, nil] if parts.empty?
+
+      lower_parts = parts.dup
+      lower_parts << 0 while lower_parts.length < 3
+      upper_parts = lower_parts.dup
+      upper_parts[parts.length - 1] += 1
+      (parts.length...upper_parts.length).each { |index| upper_parts[index] = 0 }
+      [lower_parts.join("."), upper_parts.join(".")]
     end
 
-    def parse_tilde_range(version)
-      v = Version.cached_new(version)
+    def partial_npm_version?(version)
+      constraint = version.to_s.strip.delete_prefix("v").delete_prefix("V")
+      segments = constraint.split(".", -1)
+      return false if segments.length > 3
 
-      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)
+      partial = segments.length < 3
+      segments.each do |segment|
+        if %w[* x X].include?(segment)
+          partial = true
+        elsif !VersionComparison.numeric?(segment)
+          return false
+        end
       end
+      partial
+    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"
-                      end
+    def extract_npm_operator(constraint)
+      operator = constraint[/\A(?:>=|<=|!=|>|<|=)/].to_s
+      [operator, constraint.delete_prefix(operator).strip]
+    end
 
-      VersionRange.new([
-        Interval.new(min: version, max: upper_version, min_inclusive: true, max_inclusive: false)
-      ])
+    def parse_npm_hyphen_range(lower, upper, scheme: "npm")
+      minimum = partial_npm_version?(lower) ? npm_partial_bounds(lower).fetch(0) : lower
+      if partial_npm_version?(upper)
+        maximum = npm_partial_bounds(upper).fetch(1)
+        maximum_inclusive = false
+      else
+        maximum = upper
+        maximum_inclusive = true
+      end
+      unless NpmVersion.valid?(minimum) && NpmVersion.valid?(maximum)
+        raise ArgumentError, "Invalid NPM hyphen range: #{lower} - #{upper}"
+      end
+
+      interval = Interval.new(
+        min: minimum,
+        max: maximum,
+        min_inclusive: true,
+        max_inclusive: maximum_inclusive,
+        scheme: scheme
+      )
+      VersionRange.new([interval], scheme: scheme)
     end
 
     # Gem range parsing (~>, >=, etc.)
@@ -420,9 +1043,77 @@ module Vers
 
     # Python/PyPI range parsing
     def parse_pypi_range(range_string)
-      # Handle comma-separated constraints
-      constraints = range_string.split(',').map(&:strip)
-      parse_constraints(constraints.join('|'), 'pypi')
+      constraint = range_string.to_s.strip
+      raise ArgumentError, "Empty PyPI range" if constraint.empty?
+
+      if constraint.include?(",")
+        ranges = constraint.split(",", -1).map do |part|
+          raise ArgumentError, "Empty PyPI constraint" if part.strip.empty?
+
+          parse_pypi_range(part)
+        end
+        return ranges.reduce { |combined, range| combined.intersect(range) }
+      end
+
+      return parse_pypi_compatible_range(constraint.delete_prefix("~=").strip) if constraint.start_with?("~=")
+      if constraint.start_with?("===")
+        raise ArgumentError, "PyPI arbitrary equality constraints are not supported: #{constraint}"
+      end
+      if constraint.start_with?("==") && constraint.delete_prefix("==").strip.end_with?(".*")
+        return parse_pypi_prefix_range(constraint.delete_prefix("==").strip, exclude: false)
+      end
+      if constraint.start_with?("!=") && constraint.delete_prefix("!=").strip.end_with?(".*")
+        return parse_pypi_prefix_range(constraint.delete_prefix("!=").strip, exclude: true)
+      end
+
+      constraint = "=#{constraint.delete_prefix("==").strip}" if constraint.start_with?("==")
+      parse_constraints(constraint, "pypi")
+    end
+
+    def parse_pypi_compatible_range(version)
+      parsed = PyPIVersion.parse(version)
+      unless parsed && parsed.release.length >= 2
+        raise ArgumentError, "Invalid PyPI compatible release: #{version}"
+      end
+
+      upper_release = parsed.release[0...-1].map { |part| VersionComparison.normalize_number(part) }
+      upper_release[-1] = (upper_release.fetch(-1).to_i + 1).to_s
+      upper = upper_release.join(".")
+      unless VersionComparison.compare_numbers(parsed.epoch, "0").zero?
+        upper = "#{VersionComparison.normalize_number(parsed.epoch)}!#{upper}"
+      end
+
+      interval = Interval.new(min: version, max: upper, min_inclusive: true, max_inclusive: false, scheme: "pypi")
+      VersionRange.new([interval], raw_constraints: [interval], scheme: "pypi")
+    end
+
+    def parse_pypi_prefix_range(version, exclude:)
+      prefix = version.delete_suffix(".*")
+      parsed = PyPIVersion.parse(prefix)
+      invalid = !parsed || !parsed.pre_tag.nil? || !parsed.post_number.nil? ||
+        !parsed.dev_number.nil? || parsed.local.any?
+      raise ArgumentError, "Invalid PyPI prefix constraint: #{version}" if invalid
+
+      release = parsed.release.map { |part| VersionComparison.normalize_number(part) }
+      upper_release = release.dup
+      upper_release[-1] = (upper_release.fetch(-1).to_i + 1).to_s
+      epoch = if VersionComparison.compare_numbers(parsed.epoch, "0").zero?
+                ""
+              else
+                "#{VersionComparison.normalize_number(parsed.epoch)}!"
+              end
+      lower = "#{epoch}#{release.join(".")}.dev0"
+      upper = "#{epoch}#{upper_release.join(".")}.dev0"
+
+      intervals = if exclude
+                    [
+                      Interval.less_than(lower, scheme: "pypi"),
+                      Interval.greater_than(upper, inclusive: true, scheme: "pypi")
+                    ]
+                  else
+                    [Interval.new(min: lower, max: upper, min_inclusive: true, max_inclusive: false, scheme: "pypi")]
+                  end
+      VersionRange.new(intervals, raw_constraints: intervals, scheme: "pypi")
     end
 
     # Maven range parsing
@@ -708,4 +1399,4 @@ module Vers
       parse_constraints(range_string, 'rpm')
     end
   end
-end
+end