vers 1.3.1 → 2.0.0

data/lib/vers/pub_version.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+module Vers
+  module PubVersion
+    extend self
+
+    PATTERN = /\A[0-9]+\.[0-9]+\.[0-9]+(?:-[0-9A-Za-z-]+(?:\.[0-9A-Za-z-]+)*)?(?:\+[0-9A-Za-z-]+(?:\.[0-9A-Za-z-]+)*)?\z/
+
+    def compare(left, right)
+      parsed_left = parse(left)
+      parsed_right = parse(right)
+      return Version.compare(left, right) 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 = SemverVersion.compare_prerelease(parsed_left.prerelease, parsed_right.prerelease)
+      return comparison unless comparison.zero?
+
+      compare_build(parsed_left.build, parsed_right.build)
+    end
+
+    def parse(value)
+      return nil unless PATTERN.match?(value.to_s)
+
+      SemverVersion.parse(value)
+    end
+
+    def valid?(value)
+      !parse(value.to_s.strip).nil?
+    end
+
+    def normalize(value)
+      normalized = SemverVersion.normalize(value.to_s.strip)
+      core_and_prerelease, build = normalized.split("+", 2)
+      return core_and_prerelease unless build
+
+      normalized_build = build.split(".").map do |part|
+        VersionComparison.numeric?(part) ? VersionComparison.normalize_number(part) : part
+      end
+      "#{core_and_prerelease}+#{normalized_build.join(".")}"
+    end
+
+    def prerelease?(value)
+      parsed = parse(value.to_s.strip)
+      parsed && !parsed.prerelease.empty?
+    end
+
+    def compare_build(left, right)
+      return 0 if left.empty? && right.empty?
+      return -1 if left.empty?
+      return 1 if right.empty?
+
+      SemverVersion.compare_prerelease(left, right)
+    end
+  end
+end

data/lib/vers/pypi_version.rb

@@ -0,0 +1,256 @@
+# frozen_string_literal: true
+
+require_relative "version_comparison"
+
+module Vers
+  module PyPIVersion
+    extend self
+
+    PATTERN = /\A\s*v?
+      (?:(\d+)!)?
+      (\d+(?:\.\d+)*)
+      (?:[-_.]?(alpha|beta|preview|pre|rc|a|b|c)[-_.]?(\d*))?
+      (?:(?:[-_.]?(post|rev|r)[-_.]?(\d*))|(?:-(\d+)))?
+      (?:[-_.]?(dev)[-_.]?(\d*))?
+      (?:\+([a-z0-9]+(?:[-_.][a-z0-9]+)*))?
+      \s*\z/ix
+
+    PRE_TAGS = {
+      "a" => 0,
+      "alpha" => 0,
+      "b" => 1,
+      "beta" => 1,
+      "c" => 2,
+      "rc" => 2,
+      "pre" => 2,
+      "preview" => 2
+    }.freeze
+
+    LocalPart = Data.define(:value, :numeric)
+    Parsed = Data.define(
+      :epoch,
+      :release,
+      :pre_tag,
+      :pre_number,
+      :post_number,
+      :dev_number,
+      :local
+    )
+
+    def compare(left, right)
+      parsed_left = parse(left)
+      parsed_right = parse(right)
+      comparison = compare_public_parsed(left, right, parsed_left, parsed_right)
+      return comparison unless comparison.zero?
+      return comparison unless parsed_left && parsed_right
+
+      compare_local(parsed_left.local, parsed_right.local)
+    end
+
+    def compare_public(left, right)
+      parsed_left = parse(left)
+      parsed_right = parse(right)
+      compare_public_parsed(left, right, parsed_left, parsed_right)
+    end
+
+    def compare_public_parsed(left, right, parsed_left, parsed_right)
+      return Version.compare(left, right) unless parsed_left && parsed_right
+
+      comparison = VersionComparison.compare_numbers(parsed_left.epoch, parsed_right.epoch)
+      return comparison unless comparison.zero?
+
+      comparison = compare_release(parsed_left.release, parsed_right.release)
+      return comparison unless comparison.zero?
+
+      comparison = compare_pre(parsed_left, parsed_right)
+      return comparison unless comparison.zero?
+
+      comparison = compare_post(parsed_left, parsed_right)
+      return comparison unless comparison.zero?
+
+      comparison = compare_dev(parsed_left, parsed_right)
+      return comparison unless comparison.zero?
+
+      0
+    end
+
+    def parse(value)
+      match = PATTERN.match(value.to_s)
+      return nil unless match
+
+      pre_tag = match[3]&.downcase
+      post_number = match[7] || (match[5] ? match[6] : nil)
+      local = if match[10]
+                match[10].downcase.split(/[._-]/).map do |part|
+                  LocalPart.new(part, VersionComparison.numeric?(part))
+                end
+              else
+                []
+              end
+
+      Parsed.new(
+        match[1].to_s,
+        match[2].split("."),
+        pre_tag && PRE_TAGS.fetch(pre_tag),
+        pre_tag ? match[4].to_s : nil,
+        post_number,
+        match[8] ? match[9].to_s : nil,
+        local.freeze
+      )
+    end
+
+    def valid?(value)
+      !parse(value).nil?
+    end
+
+    def prerelease?(value)
+      parsed = parse(value)
+      parsed && (!parsed.pre_tag.nil? || !parsed.dev_number.nil?)
+    end
+
+    def stable?(value)
+      parsed = parse(value)
+      parsed && parsed.pre_tag.nil? && parsed.dev_number.nil?
+    end
+
+    def normalize(value)
+      parsed = parse(value)
+      raise ArgumentError, "invalid pypi version: #{value}" unless parsed
+
+      result = +""
+      result << "#{VersionComparison.normalize_number(parsed.epoch)}!" unless VersionComparison.compare_numbers(parsed.epoch, "0").zero?
+      result << parsed.release.map { |part| VersionComparison.normalize_number(part) }.join(".")
+
+      unless parsed.pre_tag.nil?
+        result << %w[a b rc].fetch(parsed.pre_tag)
+        result << VersionComparison.normalize_number(parsed.pre_number)
+      end
+      result << ".post#{VersionComparison.normalize_number(parsed.post_number)}" unless parsed.post_number.nil?
+      result << ".dev#{VersionComparison.normalize_number(parsed.dev_number)}" unless parsed.dev_number.nil?
+
+      if parsed.local.any?
+        result << "+"
+        result << parsed.local.map { |part| part.numeric ? VersionComparison.normalize_number(part.value) : part.value }.join(".")
+      end
+
+      result
+    end
+
+    def specifier_equal?(version, specifier)
+      parsed_version = parse(version)
+      parsed_specifier = parse(specifier)
+      return compare(version, specifier).zero? unless parsed_version && parsed_specifier
+      versions_equal?(parsed_version, parsed_specifier, ignore_local: parsed_specifier.local.empty?)
+    end
+
+    def versions_equal?(left, right, ignore_local: false)
+      local_equal = ignore_local || compare_local(left.local, right.local).zero?
+      VersionComparison.compare_numbers(left.epoch, right.epoch).zero? &&
+        compare_release(left.release, right.release).zero? &&
+        compare_pre(left, right).zero? &&
+        compare_post(left, right).zero? &&
+        compare_dev(left, right).zero? &&
+        local_equal
+    end
+
+    def same_release?(left, right)
+      VersionComparison.compare_numbers(left.epoch, right.epoch).zero? &&
+        compare_release(left.release, right.release).zero?
+    end
+
+    def without_post_and_dev(version)
+      Parsed.new(
+        version.epoch,
+        version.release,
+        version.pre_tag,
+        version.pre_number,
+        nil,
+        nil,
+        [].freeze
+      )
+    end
+
+    def without_dev(version)
+      Parsed.new(
+        version.epoch,
+        version.release,
+        version.pre_tag,
+        version.pre_number,
+        version.post_number,
+        nil,
+        [].freeze
+      )
+    end
+
+    def compare_release(left, right)
+      [left.length, right.length].max.times do |index|
+        comparison = VersionComparison.compare_numbers(left[index], right[index])
+        return comparison unless comparison.zero?
+      end
+
+      0
+    end
+
+    def compare_pre(left, right)
+      left_rank = pre_rank(left)
+      right_rank = pre_rank(right)
+      comparison = left_rank <=> right_rank
+      return comparison unless comparison.zero?
+      return 0 if left.pre_tag.nil?
+
+      comparison = left.pre_tag <=> right.pre_tag
+      return comparison unless comparison.zero?
+
+      VersionComparison.compare_numbers(left.pre_number, right.pre_number)
+    end
+
+    def pre_rank(version)
+      return -1 if version.pre_tag.nil? && version.post_number.nil? && !version.dev_number.nil?
+      return 1 if version.pre_tag.nil?
+
+      0
+    end
+
+    def compare_post(left, right)
+      return 1 if !left.post_number.nil? && right.post_number.nil?
+      return -1 if left.post_number.nil? && !right.post_number.nil?
+      return 0 if left.post_number.nil?
+
+      VersionComparison.compare_numbers(left.post_number, right.post_number)
+    end
+
+    def compare_dev(left, right)
+      return -1 if !left.dev_number.nil? && right.dev_number.nil?
+      return 1 if left.dev_number.nil? && !right.dev_number.nil?
+      return 0 if left.dev_number.nil?
+
+      VersionComparison.compare_numbers(left.dev_number, right.dev_number)
+    end
+
+    def compare_local(left, right)
+      return 0 if left.empty? && right.empty?
+      return -1 if left.empty?
+      return 1 if right.empty?
+
+      [left.length, right.length].max.times do |index|
+        return -1 unless left[index]
+        return 1 unless right[index]
+
+        left_part = left[index]
+        right_part = right[index]
+        if left_part.numeric != right_part.numeric
+          return left_part.numeric ? 1 : -1
+        end
+
+        comparison = if left_part.numeric
+                       VersionComparison.compare_numbers(left_part.value, right_part.value)
+                     else
+                       left_part.value <=> right_part.value
+                     end
+        return comparison unless comparison.zero?
+      end
+
+      0
+    end
+  end
+end

data/lib/vers/scheme.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+module Vers
+  module Scheme
+    extend self
+
+    ALIASES = {
+      "rubygems" => "gem",
+      "debian" => "deb",
+      "golang" => "go",
+      "elixir" => "hex",
+      "alpine" => "apk"
+    }.freeze
+
+    HANDLERS = {
+      "alpm" => ALPMVersion,
+      "apk" => APKVersion,
+      "bazel" => BazelVersion,
+      "cargo" => CargoVersion,
+      "composer" => ComposerVersion,
+      "conan" => ConanVersion,
+      "deb" => DebianVersion,
+      "datetime" => DatetimeVersion,
+      "gem" => GemVersion,
+      "gentoo" => GentooVersion,
+      "go" => GoVersion,
+      "hex" => SemverVersion,
+      "intdot" => IntDotVersion,
+      "lexicographic" => LexicographicVersion,
+      "maven" => MavenVersion,
+      "nginx" => SemverVersion,
+      "npm" => NpmVersion,
+      "nuget" => NuGetVersion,
+      "openssl" => OpenSSLVersion,
+      "pub" => PubVersion,
+      "pypi" => PyPIVersion,
+      "rpm" => RPMVersion,
+      "semver" => SemverVersion
+    }.freeze
+
+    def canonical(value)
+      return nil if value.nil?
+
+      scheme = value.to_s.downcase
+      ALIASES.fetch(scheme, scheme)
+    end
+
+    def handler(value)
+      HANDLERS[canonical(value)]
+    end
+  end
+end

data/lib/vers/semver_version.rb

@@ -0,0 +1,294 @@
+# frozen_string_literal: true
+
+require_relative "version_comparison"
+
+module Vers
+  module SemverVersion
+    extend self
+
+    Parsed = Data.define(:core, :prerelease, :build)
+
+    def compare(left, right)
+      parsed_left = parse(left)
+      parsed_right = parse(right)
+      return left <=> right 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
+
+      compare_prerelease(parsed_left.prerelease, parsed_right.prerelease)
+    end
+
+    def parse(value)
+      string = value.to_s.strip
+      index = string.start_with?("v") ? 1 : 0
+      core = []
+
+      3.times do |part|
+        start = index
+        index += 1 while index < string.length && string.getbyte(index).between?(48, 57)
+        return nil if index == start
+
+        core << string[start...index]
+        break unless index < string.length && string.getbyte(index) == 46
+        return nil if part == 2
+
+        index += 1
+      end
+
+      core << "0" while core.length < 3
+      prerelease = ""
+      build = ""
+
+      if index < string.length && string.getbyte(index) == 45
+        start = index + 1
+        index = start
+        index += 1 while index < string.length && string.getbyte(index) != 43
+        return nil if index == start
+
+        prerelease = string[start...index]
+      end
+
+      if index < string.length && string.getbyte(index) == 43
+        index += 1
+        return nil if index == string.length || string[index..].include?("\n")
+
+        build = string[index..]
+        index = string.length
+      end
+
+      return nil unless index == string.length
+
+      Parsed.new(core.freeze, prerelease, build)
+    end
+
+    def valid?(value)
+      parsed = parse(value.to_s.strip)
+      return false unless parsed
+
+      [parsed.prerelease, parsed.build].all? do |field|
+        field.empty? || field.split(".", -1).all? { |part| part.match?(/\A[0-9A-Za-z-]+\z/) }
+      end
+    end
+
+    def normalize(value, preserve_v: false)
+      string = value.to_s.strip
+      parsed = parse(string)
+      raise ArgumentError, "Invalid semantic version: #{value}" unless parsed && valid?(string)
+
+      result = parsed.core.map { |part| VersionComparison.normalize_number(part) }.join(".")
+      result = "v#{result}" if preserve_v && string.start_with?("v")
+      unless parsed.prerelease.empty?
+        prerelease = parsed.prerelease.split(".").map do |part|
+          VersionComparison.numeric?(part) ? VersionComparison.normalize_number(part) : part
+        end
+        result += "-#{prerelease.join(".")}"
+      end
+      result += "+#{parsed.build}" unless parsed.build.empty?
+      result
+    end
+
+    def prerelease?(value)
+      parsed = parse(value.to_s.strip)
+      parsed && !parsed.prerelease.empty?
+    end
+
+    def compare_prerelease(left, right)
+      return 0 if left.empty? && right.empty?
+      return 1 if left.empty?
+      return -1 if right.empty?
+
+      left_parts = left.split(".", -1)
+      right_parts = right.split(".", -1)
+      left_parts.zip(right_parts).each do |left_part, right_part|
+        return 1 if right_part.nil?
+
+        comparison = compare_identifier(left_part, right_part)
+        return comparison unless comparison.zero?
+      end
+
+      left_parts.length <=> right_parts.length
+    end
+
+    def compare_identifier(left, right)
+      left_numeric = VersionComparison.numeric?(left)
+      right_numeric = VersionComparison.numeric?(right)
+      return -1 if left_numeric && !right_numeric
+      return 1 if !left_numeric && right_numeric
+
+      if left_numeric
+        VersionComparison.compare_numbers(left, right)
+      else
+        left <=> right
+      end
+    end
+  end
+
+  module NpmVersion
+    extend self
+
+    def compare(left, right)
+      SemverVersion.compare(left.strip, right.strip)
+    end
+
+    def valid?(value)
+      SemverVersion.valid?(value.to_s.strip)
+    end
+
+    def normalize(value)
+      SemverVersion.normalize(value.to_s.strip)
+    end
+
+    def prerelease?(value)
+      SemverVersion.prerelease?(value.to_s.strip)
+    end
+  end
+
+  module CargoVersion
+    extend self
+
+    def compare(left, right)
+      comparison = SemverVersion.compare(left, right)
+      return comparison unless comparison.zero?
+
+      parsed_left = SemverVersion.parse(left)
+      parsed_right = SemverVersion.parse(right)
+      return comparison unless parsed_left && parsed_right
+
+      compare_build(parsed_left.build, parsed_right.build)
+    end
+
+    def compare_build(left, right)
+      return 0 if left == right
+      return -1 if left.empty?
+      return 1 if right.empty?
+
+      left_parts = left.split(".", -1)
+      right_parts = right.split(".", -1)
+      left_parts.zip(right_parts).each do |left_part, right_part|
+        return 1 if right_part.nil?
+
+        comparison = compare_build_identifier(left_part, right_part)
+        return comparison unless comparison.zero?
+      end
+
+      left_parts.length <=> right_parts.length
+    end
+
+    def compare_build_identifier(left, right)
+      left_numeric = VersionComparison.numeric?(left)
+      right_numeric = VersionComparison.numeric?(right)
+      return -1 if left_numeric && !right_numeric
+      return 1 if !left_numeric && right_numeric
+      return left <=> right unless left_numeric
+
+      normalized_left = VersionComparison.normalize_number(left)
+      normalized_right = VersionComparison.normalize_number(right)
+      comparison = normalized_left.length <=> normalized_right.length
+      return comparison unless comparison.zero?
+
+      comparison = normalized_left <=> normalized_right
+      return comparison unless comparison.zero?
+
+      left.length <=> right.length
+    end
+
+    def valid?(value)
+      SemverVersion.valid?(value.to_s.strip)
+    end
+
+    def normalize(value)
+      SemverVersion.normalize(value.to_s.strip)
+    end
+
+    def prerelease?(value)
+      SemverVersion.prerelease?(value.to_s.strip)
+    end
+  end
+
+  module GoVersion
+    extend self
+
+    def compare(left, right)
+      return SemverVersion.compare(left, right) unless left.start_with?("v") || right.start_with?("v")
+
+      parsed_left = parse(left)
+      parsed_right = parse(right)
+      return 1 if parsed_left && !parsed_right
+      return -1 if !parsed_left && parsed_right
+      return 0 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
+
+      SemverVersion.compare_prerelease(parsed_left.prerelease, parsed_right.prerelease)
+    end
+
+    def parse(value)
+      return nil unless value.start_with?("v")
+
+      string = value.delete_prefix("v")
+      core_end = string.index(/[-+]/) || string.length
+      core = string[0...core_end].split(".", -1)
+      return nil if core.empty? || core.length > 3
+      return nil unless core.all? { |part| valid_core_part?(part) }
+      return nil if core.length < 3 && core_end != string.length
+
+      core << "0" while core.length < 3
+      remainder = string[core_end..]
+      prerelease = ""
+      build = ""
+
+      if remainder.start_with?("-")
+        value = remainder.delete_prefix("-")
+        prerelease_end = value.index("+") || value.length
+        prerelease = value[0...prerelease_end]
+        return nil unless valid_identifiers?(prerelease, build: false)
+
+        remainder = value[prerelease_end..]
+      end
+
+      if remainder.start_with?("+")
+        build = remainder.delete_prefix("+")
+        return nil unless valid_identifiers?(build, build: true)
+
+        remainder = ""
+      end
+
+      return nil unless remainder.empty?
+
+      SemverVersion::Parsed.new(core.freeze, prerelease, build)
+    end
+
+    def valid_core_part?(part)
+      VersionComparison.numeric?(part) && (part == "0" || !part.start_with?("0"))
+    end
+
+    def valid_identifiers?(value, build:)
+      return false if value.empty?
+
+      value.split(".", -1).all? do |identifier|
+        next false unless identifier.match?(/\A[0-9A-Za-z-]+\z/)
+
+        build || identifier == "0" || !VersionComparison.numeric?(identifier) || !identifier.start_with?("0")
+      end
+    end
+
+    def valid?(value)
+      string = value.to_s.strip
+      string.start_with?("v") ? !parse(string).nil? : SemverVersion.valid?(string)
+    end
+
+    def normalize(value)
+      SemverVersion.normalize(value.to_s.strip, preserve_v: true)
+    end
+
+    def prerelease?(value)
+      SemverVersion.prerelease?(value.to_s.strip)
+    end
+  end
+end