semver_dialects 2.0.2 → 3.0.0

data/lib/semver_dialects/interval_set_parser.rb

@@ -0,0 +1,205 @@
+# frozen_string_literal: true
+
+# IntervalSetParser parses a string that represents an interval set
+# in a syntax that's specific to a package type.
+module SemverDialects
+  module IntervalSetParser
+    # parse parses a string and returns an IntervalSet.
+    # The string is expected to be in a syntax that's specific the given package type.
+    def self.parse(typ, interval_set_string)
+      IntervalSet.new.tap do |set|
+        translate(typ, interval_set_string).each do |interval_str|
+          set << IntervalParser.parse(typ, interval_str)
+        end
+      end
+    end
+
+    def self.translate(typ, interval_set_string)
+      case typ
+      when 'maven'
+        translate_maven(interval_set_string)
+      when 'npm'
+        translate_npm(interval_set_string)
+      when 'conan'
+        translate_conan(interval_set_string)
+      when 'nuget'
+        translate_nuget(interval_set_string)
+      when 'go'
+        translate_go(interval_set_string)
+      when 'gem'
+        translate_gem(interval_set_string)
+      when 'pypi'
+        translate_pypi(interval_set_string)
+      when 'packagist'
+        translate_packagist(interval_set_string)
+      else
+        raise UnsupportedPackageTypeError, typ
+      end
+    end
+
+    def self.translate_npm(interval_set_string)
+      interval_set_string.split('||').map do |item|
+        add_missing_operator(single_space_after_operator(item.strip.gsub(/&&/, ' ')))
+      end
+    end
+
+    def self.translate_conan(interval_set_string)
+      translate_npm(interval_set_string)
+    end
+
+    def self.translate_go(interval_set_string)
+      translate_gem(interval_set_string)
+    end
+
+    def self.translate_gem(interval_set_string)
+      interval_set_string.split('||').map do |item|
+        add_missing_operator(single_space_after_operator(item.strip.gsub(/\s+/, ' ')))
+      end
+    end
+
+    def self.translate_packagist(interval_set_string)
+      translate_pypi(interval_set_string)
+    end
+
+    def self.translate_pypi(interval_set_string)
+      interval_set_string.split('||').map do |item|
+        add_missing_operator(single_space_after_operator(comma_to_space(item)))
+      end
+    end
+
+    def self.translate_nuget(interval_set_string)
+      translate_maven(interval_set_string)
+    end
+
+    def self.translate_maven(interval_set_string)
+      lexing_maven_interval_set_string(interval_set_string).map { |item| translate_mvn_version_item(item) }
+    end
+
+    def self.add_missing_operator(interval_set_string)
+      starts_with_operator?(interval_set_string) ? interval_set_string : "=#{interval_set_string}"
+    end
+
+    def self.single_space_after_operator(interval_set_string)
+      interval_set_string.gsub(/([>=<]+) +/, '\1').gsub(/\s+/, ' ')
+    end
+
+    def self.starts_with_operator?(version_item)
+      version_item.match(/^[=><]/) ? true : false
+    end
+
+    def self.comma_to_space(interval_set_string)
+      interval_set_string.strip.gsub(/,/, ' ')
+    end
+
+    def self.lexing_maven_interval_set_string(interval_set_string)
+      open = false
+      substring = ''
+      ret = []
+      interval_set_string.each_char do |c|
+        case c
+        when '(', '['
+          if open
+            puts "malformed maven version string #{interval_set_string}"
+            exit(-1)
+          else
+            unless substring.empty?
+              ret << substring
+              substring = ''
+            end
+            open = true
+            substring += c
+          end
+        when ')', ']'
+          if !open
+            puts "malformed maven version string #{interval_set_string}"
+            exit(-1)
+          else
+            open = false
+            substring += c
+            ret << substring
+            substring = ''
+          end
+        when ','
+          substring += c if open
+        when ' '
+          # nothing to do
+          substring += ''
+        else
+          substring += c
+        end
+      end
+      if open
+        puts "malformed maven version string #{interval_set_string}"
+        exit(-1)
+      end
+      ret << substring unless substring.empty?
+      ret
+    end
+
+    def self.parenthesized?(version_item)
+      version_item.match(/^[(\[]/) && version_item.match(/[\])]$/)
+    end
+
+    def self.translate_mvn_version_item(version_item)
+      content = ''
+      parens_pattern = ''
+      if parenthesized?(version_item)
+        content = version_item[1, version_item.size - 2]
+        parens_pattern = version_item[0] + version_item[version_item.size - 1]
+        # special case -- unversal version range
+        return '=*' if content.strip == ','
+      else
+        # according to the doc, if there is a plain version string in maven, it means 'starting from version x'
+        # https://docs.oracle.com/middleware/1212/core/MAVEN/maven_version.htm#MAVEN8903
+        content = "#{version_item},"
+        parens_pattern = '[)'
+      end
+
+      args = content.split(',')
+      first_non_empty_arg = args.find(&:range_present?)
+
+      if content.start_with?(',')
+        # {,y}
+        case parens_pattern
+        when '[]'
+          "<=#{first_non_empty_arg}"
+        when '()'
+          "<#{first_non_empty_arg}"
+        when '[)'
+          "<#{first_non_empty_arg}"
+        else
+          # par_pattern == "(]"
+          "<=#{first_non_empty_arg}"
+        end
+      elsif content.end_with?(',')
+        # {x,}
+        case parens_pattern
+        when '[]'
+          ">=#{first_non_empty_arg}"
+        when '()'
+          ">#{first_non_empty_arg}"
+        when '[)'
+          ">=#{first_non_empty_arg}"
+        else
+          # par_pattern == "(]"
+          ">#{first_non_empty_arg}"
+        end
+      elsif content[','].nil?
+        # [x,x]
+        "=#{content}"
+      else
+        case parens_pattern
+        when '[]'
+          ">=#{args[0]} <=#{args[1]}"
+        when '()'
+          ">#{args[0]} <#{args[1]}"
+        when '[)'
+          ">=#{args[0]} <#{args[1]}"
+        else
+          # par_pattern == "(]"
+          ">#{args[0]} <=#{args[1]}"
+        end
+      end
+    end
+  end
+end

data/lib/semver_dialects/maven.rb

@@ -0,0 +1,197 @@
+# frozen_string_literal: true
+
+require 'strscan'
+
+module SemverDialects
+  module Maven
+    ALPHA = -5
+    BETA = -4
+    MILESTONE = -3
+    RC = -2
+    SNAPSHOT = -1
+    SP = 'sp'
+
+    class Version < BaseVersion
+      attr_accessor :addition
+
+      # Return an array similar to the one Maven generates when parsing versions.
+      #
+      #   $ java -jar ${MAVEN_HOME}/lib/maven-artifact-3.9.6.jar 1a1
+      #   Display parameters as parsed by Maven (in canonical form and as a list of tokens) and comparison result:
+      #    1. 1a1 -> 1-alpha-1; tokens: [1, [alpha, [1]]]
+      #
+      def to_a
+        return tokens if addition.nil?
+
+        tokens.clone.append(addition.to_a)
+      end
+
+      def to_s(as_addition = false)
+        s = ''
+        if tokens.any?
+          s += '-' if as_addition
+          s += tokens.map do |token|
+            case token
+            when String
+              token
+            when Integer
+              case token
+              when ALPHA
+                'alpha'
+              when BETA
+                'beta'
+              when MILESTONE
+                'milestone'
+              when RC
+                'rc'
+              when SNAPSHOT
+                'snapshot'
+              else
+                token.to_s
+              end
+            end
+          end.join('.')
+        end
+        s += addition.to_s(true) if addition
+        s
+      end
+
+      private
+
+      # Compare tokens as specified in https://maven.apache.org/pom.html#version-order-specification.
+      # Negative integers are alpha, beta, milestone, rc, and snapshot qualifiers.
+      # Special qualifier "sp" is right after GA and before any lexical or numeric token.
+      # Strings should be converted to lower case before being compared by this method.
+      # 1-a0 == 1-alpha < 1-0 == 1 == 1final == 1 ga < 1sp < 1-a < 1-1
+      def compare_token_pair(a = 0, b = 0)
+        a ||= 0
+        b ||= 0
+
+        if a.is_a?(Integer) && b.is_a?(String)
+          return a <= 0 ? -1 : 1
+        end
+
+        if a.is_a?(String) && b.is_a?(Integer)
+          return b <= 0 ? 1 : -1
+        end
+
+        return -1 if a == SP && b.is_a?(String) && b != SP
+
+        return 1 if b == SP && a.is_a?(String) && a != SP
+
+        # Identifiers have both the same type.
+        # This returns nil if the identifiers can't be compared.
+        a <=> b
+      end
+
+      def empty_addition
+        Version.new([])
+      end
+    end
+
+    class VersionParser
+      def self.parse(input)
+        new(input).parse
+      end
+
+      attr_reader :input
+
+      def initialize(input)
+        @input = input
+      end
+
+      def parse
+        @scanner = StringScanner.new(input.downcase)
+        @version = Version.new([])
+        @result = @version
+        parse_version(false)
+        result
+      end
+
+      private
+
+      attr_reader :scanner, :version, :result
+
+      # Parse a version and all its additions recursively.
+      # It automatically creates a new partition for numbers
+      # if number_begins_partition is true.
+      def parse_version(number_begins_partition)
+        # skip leading v if any
+        scanner.skip(/v/)
+
+        until scanner.eos?
+          if (s = scanner.scan(/\d+/))
+            if number_begins_partition
+              parse_addition(s.to_i)
+            else
+              version.tokens << s.to_i
+            end
+
+          elsif (s = scanner.match?(/a\d+/))
+            # aN is equivalent to alpha-N
+            scanner.skip('a')
+            parse_addition(ALPHA)
+
+          elsif (s = scanner.match?(/b\d+/))
+            # bN is equivalent to beta-N
+            scanner.skip('b')
+            parse_addition(BETA)
+
+          elsif (s = scanner.match?(/m\d+/))
+            # mN is equivalent to milestone-N
+            scanner.skip('m')
+            parse_addition(MILESTONE)
+
+          elsif (s = scanner.scan(/(alpha|beta|milestone|rc|cr|sp|ga|final|release|snapshot)[a-z]+/))
+            # process "alpha" and others as normal lexical tokens if they're followed by a letter
+            parse_addition(s)
+
+          elsif (s = scanner.scan('alpha'))
+            # handle alphaN, alpha-X, alpha.X, or ending alpha
+            parse_addition(ALPHA)
+
+          elsif (s = scanner.scan('beta'))
+            parse_addition(BETA)
+
+          elsif (s = scanner.scan('milestone'))
+            parse_addition(MILESTONE)
+
+          elsif (s = scanner.scan(/(rc|cr)/))
+            parse_addition(RC)
+
+          elsif (s = scanner.scan('snapshot'))
+            parse_addition(SNAPSHOT)
+
+          elsif (s = scanner.scan(/ga|final|release/))
+            parse_addition
+
+          elsif (s = scanner.scan('sp'))
+            parse_addition(SP)
+
+          elsif (s = scanner.scan(/[a-z]+/))
+            parse_addition(s)
+
+          elsif (s = scanner.scan('.'))
+            number_begins_partition = false
+
+          elsif (s = scanner.scan('-'))
+            number_begins_partition = true
+
+          else
+            raise IncompleteScanError, scanner.rest
+          end
+        end
+      end
+
+      # Create an addition for the current version, make it the current version, and parse it.
+      # Numbers start a new partition.
+      def parse_addition(token = nil)
+        version.addition = Version.new([token].compact)
+        @version = version.addition
+
+        scanner.skip(/-+/)
+        parse_version(true)
+      end
+    end
+  end
+end

data/lib/semver_dialects/semantic_version.rb

@@ -0,0 +1,294 @@
+# frozen_string_literal: true
+
+require_relative '../utils'
+
+# SemanticVersion represents a Semver 2 version.
+# Comparison rules are the ones of Semver 2.
+module SemverDialects
+  class SemanticVersion
+    attr_reader :version_string, :prefix_segments, :suffix_segments, :segments
+
+    # String to build a regexp that matches a version.
+    #
+    # A version might start with a leading "v", then it must have a digit,
+    # then it might have any sequence made of alphanumerical characters,
+    # underscores, dots, dashes, and wildcards.
+    VERSION_PATTERN = 'v?[0-9][a-zA-Z0-9_.*+-]*'
+
+    # Regexp for a string that only contains a single version string.
+    VERSION_ONLY_REGEXP = Regexp.new("\\A#{VERSION_PATTERN}\\z").freeze
+
+    def initialize(version_string)
+      raise InvalidVersionError, version_string unless VERSION_ONLY_REGEXP.match version_string
+
+      @version_string = version_string
+      @prefix_segments = []
+      @suffix_segments = []
+      version, = version_string.delete_prefix('v').split('+')
+      @segments = split_version_string!(version)
+    end
+
+    def split_version_string!(version_string)
+      delim_pattern = /[.-]/
+      split_array = version_string.split(delim_pattern).map do |grp|
+        grp.split(/(\d+)/).reject { |cell| cell.nil? || cell.empty? }
+      end.flatten
+
+      # go as far to the right as possible considering numbers and placeholders
+      prefix_delimiter = 0
+      (0..split_array.size - 1).each do |i|
+        break unless split_array[i].number? || split_array[i] == 'X' || split_array[i] == 'x'
+
+        prefix_delimiter = i
+      end
+
+      # remove redundant trailing zeros
+      prefix_delimiter.downto(0).each do |i|
+        break unless split_array[i] == '0'
+
+        split_array.delete_at(i)
+        prefix_delimiter -= 1
+      end
+
+      unless prefix_delimiter < 0
+        @prefix_segments = split_array[0..prefix_delimiter].map do |group_string|
+          SemanticVersionSegment.new(group_string)
+        end
+      end
+      if split_array.size - 1 >= prefix_delimiter + 1
+        @suffix_segments = split_array[prefix_delimiter + 1, split_array.size].map do |group_string|
+          SemanticVersionSegment.new(group_string)
+        end
+      end
+
+      @prefix_segments.clone.concat(@suffix_segments)
+    end
+
+    def _get_equalized_arrays_for(array_a, array_b)
+      first_array = array_a.clone
+      second_array = array_b.clone
+      if first_array.size < second_array.size
+        (second_array.size - first_array.size).times do
+          first_array << SemanticVersionSegment.new('0')
+        end
+      elsif first_array.size > second_array.size
+        (first_array.size - second_array.size).times do
+          second_array << SemanticVersionSegment.new('0')
+        end
+      end
+      [first_array, second_array]
+    end
+
+    def get_equalized_arrays_for(semver_a, semver_b)
+      first_array_prefix = semver_a.prefix_segments.clone
+      second_array_prefix = semver_b.prefix_segments.clone
+      first_array_suffix = semver_a.suffix_segments.clone
+      second_array_suffix = semver_b.suffix_segments.clone
+      first_array_prefix, second_array_prefix = _get_equalized_arrays_for(first_array_prefix, second_array_prefix)
+      first_array_suffix, second_array_suffix = _get_equalized_arrays_for(first_array_suffix, second_array_suffix)
+      [first_array_prefix.concat(first_array_suffix), second_array_prefix.concat(second_array_suffix)]
+    end
+
+    def get_equalized_prefix_arrays_for(semver_a, semver_b)
+      first_array_prefix = semver_a.prefix_segments.clone
+      second_array_prefix = semver_b.prefix_segments.clone
+      first_array_prefix, second_array_prefix = _get_equalized_arrays_for(first_array_prefix, second_array_prefix)
+      [first_array_prefix, second_array_prefix]
+    end
+
+    def <(other)
+      self_array, other_array = get_equalized_arrays_for(self, other)
+      (0..self_array.size - 1).each do |i|
+        if self_array[i] < other_array[i]
+          return true
+        elsif self_array[i] > other_array[i]
+          return false
+        end
+      end
+      false
+    end
+
+    def is_zero?
+      @prefix_segments.empty? || @prefix_segments.all?(&:is_zero?)
+    end
+
+    def pre_release?
+      @suffix_segments.any?(&:is_pre_release)
+    end
+
+    def post_release?
+      @suffix_segments.any?(&:is_post_release)
+    end
+
+    def >(other)
+      self_array, other_array = get_equalized_arrays_for(self, other)
+      (0..self_array.size - 1).each do |i|
+        if self_array[i] > other_array[i]
+          return true
+        elsif self_array[i] < other_array[i]
+          return false
+        end
+      end
+      false
+    end
+
+    def >=(other)
+      self == other || self > other || self == other
+    end
+
+    def <=(other)
+      self == other || self < other
+    end
+
+    def ==(other)
+      segments_a = []
+      segments_b = []
+
+      segments_a += other.segments
+      segments_b += @segments
+
+      if other.segments.size < @segments.size
+        (@segments.size - other.segments.size).times { |_| segments_a << SemanticVersionSegment.new('0') }
+      elsif other.segments.size > @segments.size
+        (other.segments.size - @segments.size).times { |_| segments_b << SemanticVersionSegment.new('0') }
+      end
+
+      (0..segments_a.size - 1).each do |i|
+        return false if segments_a[i] != segments_b[i]
+      end
+      true
+    end
+
+    def !=(other)
+      !(self == other)
+    end
+
+    def to_normalized_s
+      @segments.map(&:to_normalized_s).join(':')
+    end
+
+    def to_s
+      @version_string
+    end
+
+    def minor
+      @prefix_segments.size >= 1 ? @prefix_segments[1].to_s : '0'
+    end
+
+    def major
+      @prefix_segments.size >= 2 ? @prefix_segments[0].to_s : '0'
+    end
+
+    def patch
+      @prefix_segments.size >= 3 ? @prefix_segments[2].to_s : '0'
+    end
+  end
+
+  class SemanticVersionSegment
+    attr_accessor :normalized_group_string, :original_group_string, :is_post_release, :is_pre_release
+
+    @@group_suffixes = {
+      # pre-releases
+      'PRE' => -16,
+      'PREVIEW' => -16,
+      'DEV' => -15,
+      'A' => -14,
+      'ALPHA' => -13,
+      'B' => -12,
+      'BETA' => -12,
+      'RC' => -11,
+      'M' => -10,
+
+      'RELEASE' => 0,
+      'FINAL' => 0,
+      # PHP specific
+      'STABLE' => 0,
+
+      # post-releases
+      'SP' => 1
+    }
+
+    def initialize(group_string)
+      @is_post_release = false
+      @is_pre_release = false
+
+      @version_string = group_string
+      @original_group_string = group_string
+      # use x as unique placeholder
+      group_string_ucase = group_string.to_s.gsub(/\*/, 'x').upcase
+
+      if @@group_suffixes.key?(group_string_ucase)
+        value = @@group_suffixes[group_string_ucase]
+        @is_post_release = value > 0
+        @is_pre_release = value < 0
+        @normalized_group_string = @@group_suffixes[group_string_ucase].to_s
+      else
+        @normalized_group_string = group_string_ucase
+      end
+    end
+
+    def compare(semver_a, semver_b, ret_anr_bnonr, ret_anonr_bnr, comparator)
+      if semver_a.number? && semver_b.number?
+        semver_a.to_i.send(comparator, semver_b.to_i)
+      elsif semver_a.number? && !semver_b.number?
+        if semver_b == 'X'
+          true
+        else
+          ret_anr_bnonr
+        end
+      elsif !semver_a.number? && semver_b.number?
+        if semver_a == 'X'
+          true
+        else
+          ret_anonr_bnr
+        end
+      elsif semver_a == 'X' || semver_b == 'X' # !semantic_version_b.group_string.is_number? && !semantic_version_agrous_string.is_number?
+        true
+      else
+        semver_a.send(comparator, semver_b)
+      end
+    end
+
+    def <(other)
+      compare(normalized_group_string, other.normalized_group_string, true, false, :<)
+    end
+
+    def >(other)
+      compare(normalized_group_string, other.normalized_group_string, false, true, :>)
+    end
+
+    def >=(other)
+      self == other || compare(normalized_group_string, other.normalized_group_string, false, true,
+                               :>)
+    end
+
+    def <=(other)
+      self == other || compare(normalized_group_string, other.normalized_group_string, true, false,
+                               :<)
+    end
+
+    def ==(other)
+      normalized_group_string == other.normalized_group_string
+    end
+
+    def !=(other)
+      !(self == other)
+    end
+
+    def to_normalized_s
+      @normalized_group_string
+    end
+
+    def to_s
+      @version_string
+    end
+
+    def is_number?
+      normalized_group_string.number?
+    end
+
+    def is_zero?
+      is_number? ? normalized_group_string.to_i == 0 : false
+    end
+  end
+end