semver_dialects 2.0.2 → 3.0.0

data/lib/semver_dialects/semantic_version/version_interval.rb

@@ -1,288 +0,0 @@
-module IntervalType
-  UNKNOWN = 0
-  LEFT_OPEN = 1
-  LEFT_CLOSED = 2
-  RIGHT_OPEN = 4
-  RIGHT_CLOSED = 8
-end
-
-class VersionInterval
-  attr_accessor :type, :start_cut, :end_cut
-
-  def initialize(type, start_cut, end_cut)
-    @type = type
-    @start_cut = start_cut
-    @end_cut = end_cut
-  end
-
-  def intersect(other_interval)
-    return EmptyInterval.new if self.empty?
-
-    # this look odd -- we have to use it here though, because it may be that placeholders are present inside
-    # the version for which > and < would yield true
-    return EmptyInterval.new if !(@start_cut <= other_interval.end_cut) || !(other_interval.start_cut <= @end_cut)
-
-    start_cut_new = max(@start_cut, other_interval.start_cut)
-    end_cut_new = min(@end_cut, other_interval.end_cut)
-
-    # compute the boundaries for the intersection
-    type = compute_intersection_boundary(self, other_interval, start_cut_new, end_cut_new)
-    interval = VersionInterval.new(type, start_cut_new, end_cut_new)
-    half_open = !(interval.bit_set?(IntervalType::RIGHT_CLOSED) && interval.bit_set?(IntervalType::LEFT_CLOSED))
-
-    interval.singleton? && half_open ? EmptyInterval.new : interval
-  end
-
-  def union(other_interval)
-    return EmptyInterval.new if self.intersect(other_interval).instance_of?(EmptyInterval)
-
-    start_cut_new = min(@start_cut, other_interval.start_cut)
-    end_cut_new = max(@end_cut, other_interval.end_cut)
-
-    # compute the boundaries for the union
-    type = compute_union_boundary(self, other_interval, start_cut_new, end_cut_new)
-    VersionInterval.new(type, start_cut_new, end_cut_new)
-  end
-
-  def collapse(other_interval)
-    return EmptyInterval.new if self.intersect(other_interval).instance_of?(EmptyInterval)
-
-    frame = [@start_cut, other_interval.start_cut, @end_cut, other_interval.end_cut].reject { |cut| special(cut) }
-    min_cut = frame.reduce { |smallest, current| smallest < current ? smallest : current }
-    max_cut = frame.reduce { |biggest, current| biggest > current ? biggest : current }
-
-    # compute the boundaries for the union
-    type = compute_union_boundary(self, other_interval, min_cut, max_cut)
-    VersionInterval.new(type, min_cut, max_cut)
-  end
-
-  def special(cut)
-    cut.instance_of?(AboveAll) || cut.instance_of?(BelowAll)
-  end
-
-  def to_s
-    s = ""
-    s += bit_set?(IntervalType::LEFT_CLOSED) ? "[" : ""
-    s += bit_set?(IntervalType::LEFT_OPEN) ? "(" : ""
-    s += [@start_cut, @end_cut].join(",")
-    s += bit_set?(IntervalType::RIGHT_CLOSED) ? "]" : ""
-    s += bit_set?(IntervalType::RIGHT_OPEN) ? ")" : ""
-    s
-  end
-
-# this function returns a human-readable descriptions of the version strings
-  def to_description_s
-    s = ""
-    if self.distinct?
-      s = "version #{@start_cut.to_s}"
-    elsif self.universal?
-      s = "all versions "
-    else
-      s = "all versions "
-      s += start_cut.instance_of?(BelowAll) ? "" : bit_set?(IntervalType::LEFT_OPEN) ? "after #{@start_cut.to_s} " : bit_set?(IntervalType::LEFT_CLOSED) ? "starting from #{@start_cut.to_s} " : ""
-      s += end_cut.instance_of?(AboveAll) ? "" : bit_set?(IntervalType::RIGHT_OPEN) ? "before #{@end_cut.to_s}" : bit_set?(IntervalType::RIGHT_CLOSED) ? "up to #{@end_cut.to_s}" : ""
-    end
-    s.strip
-  end
-
-  def to_nuget_s
-    to_maven_s
-  end
-
-  def to_maven_s
-    s = ""
-    # special case -- distinct version
-    if self.distinct?
-      s += "[#{@start_cut.to_s}]"
-    else
-      s += start_cut.instance_of?(BelowAll) ? "(," : bit_set?(IntervalType::LEFT_OPEN) ? "[#{@start_cut.to_s}," : bit_set?(IntervalType::LEFT_CLOSED) ? "[#{@start_cut.to_s}," : ""
-      s += end_cut.instance_of?(AboveAll) ? ")" : bit_set?(IntervalType::RIGHT_OPEN) ? "#{@end_cut.to_s})" : bit_set?(IntervalType::RIGHT_CLOSED) ? "#{@end_cut.to_s}]" : ""
-    end
-    s
-  end
-
-  def distinct?
-    bit_set?(IntervalType::LEFT_CLOSED) && bit_set?(IntervalType::RIGHT_CLOSED) && @start_cut == @end_cut
-  end
-
-  def subsumes?(other)
-    @start_cut <= other.start_cut && @end_cut >= other.end_cut
-  end
-
-  def universal?
-    (bit_set?(IntervalType::LEFT_OPEN) && bit_set?(IntervalType::RIGHT_OPEN) && @start_cut.instance_of?(BelowAll) && @end_cut.instance_of?(AboveAll)) || @start_cut.is_initial_version? && @end_cut.instance_of?(AboveAll)
-  end
-
-  def to_gem_s
-    get_canoncial_s
-  end
-
-  def to_ruby_s
-    get_canoncial_s
-  end
-
-  def to_npm_s
-    get_canoncial_s
-  end
-
-  def to_conan_s
-    get_canoncial_s
-  end
-
-  def to_go_s
-    get_canoncial_s
-  end
-
-  def to_pypi_s
-    get_canoncial_s(',', '==')
-  end
-
-  def to_packagist_s
-    get_canoncial_s(',')
-  end
-
-  def empty?
-    self.instance_of?(EmptyInterval)
-  end
-
-  def singleton?
-    @start_cut == @end_cut && @start_cut.value == @end_cut.value
-  end
-
-  def diff(other_interval, abs = true)
-    if self.distinct? && other_interval.distinct?
-      self.start_cut.diff(other_interval.start_cut, abs)
-    else
-      EmptyInterval.new()
-    end
-  end
-
-  def joinable?(other_interval)
-    other_interval.start_cut.is_successor_of?(self.end_cut) || universal?
-  end
-
-  def join(other_interval)
-    if self.joinable?(other_interval)
-      _join(self, other_interval)
-    elsif other_interval.joinable?(self)
-      _join(other_interval, self)
-    else
-      EmptyInterval.new()
-    end
-  end
-
-  def cross_total
-    if distinct?
-      @start_cut.cross_total
-    else
-      @start_cut.cross_total + @end_cut.cross_total
-    end
-  end
-
-  def ==(other_interval)
-    @start_cut == other_interval.start_cut && @end_cut == other_interval.end_cut && @type == other_interval.type
-  end
-
-# inverts the given version interval -- note that this function amy return two version intervals
-# e.g., (2,10] -> (-inf, 2], (10, +inf)
-#                 left       right
-  def invert
-    intervals = []
-    left_type = bit_set?(IntervalType::LEFT_OPEN) ? IntervalType::RIGHT_CLOSED : IntervalType::RIGHT_OPEN
-    left_type = left_type | IntervalType::LEFT_OPEN
-    right_type = bit_set?(IntervalType::RIGHT_OPEN) ? IntervalType::LEFT_CLOSED : IntervalType::LEFT_OPEN
-    right_type = right_type | IntervalType::RIGHT_OPEN
-
-    intervals << VersionInterval.new(left_type, BelowAll.new, @start_cut) unless @start_cut.instance_of?(BelowAll)
-    intervals << VersionInterval.new(right_type, @end_cut, AboveAll.new) unless @end_cut.instance_of?(AboveAll)
-    intervals
-  end
-
-  def bit_set?(interval_type)
-    @type & interval_type != 0
-  end
-
-  protected
-
-# computes the boundary type for union operation
-  def compute_union_boundary(interval_a, interval_b, start_cut_new, end_cut_new)
-    compute_boundary(interval_a, interval_b, start_cut_new, end_cut_new, IntervalType::LEFT_CLOSED, IntervalType::RIGHT_CLOSED)
-  end
-
-  def compute_intersection_boundary(interval_a, interval_b, start_cut_new, end_cut_new)
-    compute_boundary(interval_a, interval_b,start_cut_new, end_cut_new, IntervalType::LEFT_OPEN, IntervalType::RIGHT_OPEN)
-  end
-
-  def compute_boundary(interval_a, interval_b, start_cut_new, end_cut_new, left_check, right_check)
-    start_cut_a = interval_a.start_cut
-    end_cut_a = interval_a.end_cut
-    type_a = interval_a.type
-
-    start_cut_b = interval_b.start_cut
-    end_cut_b = interval_b.end_cut
-    type_b = interval_b.type
-
-    left_fill = left_check == IntervalType::LEFT_OPEN ? IntervalType::LEFT_CLOSED : IntervalType::LEFT_OPEN
-    right_fill = right_check == IntervalType::RIGHT_OPEN ? IntervalType::RIGHT_CLOSED : IntervalType::RIGHT_OPEN
-
-    # compute the boundaries for the union
-    if start_cut_b == start_cut_a && start_cut_b == start_cut_b
-      one_left_closed = left_type(type_a) == left_check || left_type(type_b) == left_check
-      left_type = one_left_closed ? left_check : left_fill
-    else
-      left_type = start_cut_new == start_cut_a ? left_type(type_a) : left_type(type_b)
-    end
-
-    if end_cut_b == end_cut_a && end_cut_b == end_cut_b
-      one_right_closed = right_type(type_a) == right_check || right_type(type_b) == right_check
-      right_type = one_right_closed ? right_check : right_fill
-    else
-      right_type = end_cut_new == end_cut_a ? right_type(type_a) : right_type(type_b)
-    end
-
-    left_type | right_type
-  end
-
-  def _join(first_interval, second_interval)
-    if first_interval.joinable?(second_interval)
-      VersionInterval.new(first_interval.type, first_interval.start_cut.dup, second_interval.end_cut.dup)
-    else
-      EmptyInterval.new()
-    end
-  end
-
-  def get_canoncial_s(delimiter = " ", eq = '=')
-    if self.distinct?
-      "#{eq}#{@start_cut.to_s}"
-    else
-      first = start_cut.instance_of?(BelowAll) ? "" : bit_set?(IntervalType::LEFT_OPEN) ? ">#{@start_cut.to_s}" : bit_set?(IntervalType::LEFT_CLOSED) ? ">=#{@start_cut.to_s}" : ""
-      second = end_cut.instance_of?(AboveAll) ? "" : bit_set?(IntervalType::RIGHT_OPEN) ? "<#{@end_cut.to_s}" : bit_set?(IntervalType::RIGHT_CLOSED) ? "<=#{@end_cut.to_s}" : ""
-      !first.empty? && !second.empty? ? "#{first}#{delimiter}#{second}" : first + second
-    end
-  end
-
-  def max(cut_a, cut_b)
-    cut_a > cut_b ? cut_a : cut_b
-  end
-
-  def min(cut_a, cut_b)
-    cut_a < cut_b ? cut_a : cut_b
-  end
-
-  def right_type(type)
-    (IntervalType::RIGHT_OPEN | IntervalType::RIGHT_CLOSED) & type
-  end
-
-  def left_type(type)
-    (IntervalType::LEFT_OPEN | IntervalType::LEFT_CLOSED) & type
-  end
-end
-
-class EmptyInterval < VersionInterval
-  def initialize()
-  end
-
-  def to_s
-    "empty"
-  end
-end

data/lib/semver_dialects/semantic_version/version_parser.rb

@@ -1,40 +0,0 @@
-require_relative "version_cut"
-require_relative "version_interval"
-
-module VersionParser
-  # A constraint is made of an operator followed by a version string.
-  CONSTRAINT_REGEXP = Regexp.new("(?<op>[><=]+) *(?<version>#{SemanticVersion::VERSION_PATTERN})").freeze
-
-  def self.parse(versionstring)
-    if (versionstring == "=*")
-      # special case = All Versions
-      return VersionInterval.new(IntervalType::LEFT_OPEN | IntervalType::RIGHT_OPEN, BelowAll.new(), AboveAll.new())
-    end
-
-    version_items = versionstring.split(" ")
-    interval = VersionInterval.new(IntervalType::LEFT_OPEN | IntervalType::RIGHT_OPEN, BelowAll.new(), AboveAll.new())
-    version_items.each do |version_item|
-      matches = version_item.match CONSTRAINT_REGEXP
-      raise SemverDialects::InvalidConstraintError, versionstring if matches.nil?
-      version_string = matches[:version]
-      case matches[:op]
-      when ">="
-        new_interval = VersionInterval.new(IntervalType::LEFT_CLOSED | IntervalType::RIGHT_OPEN, VersionCut.new(version_string), AboveAll.new())
-        interval = interval.intersect(new_interval)
-      when "<="
-        new_interval = VersionInterval.new(IntervalType::LEFT_OPEN | IntervalType::RIGHT_CLOSED, BelowAll.new(), VersionCut.new(version_string))
-        interval = interval.intersect(new_interval)
-      when "<"
-        new_interval = VersionInterval.new(IntervalType::LEFT_OPEN | IntervalType::RIGHT_OPEN, BelowAll.new(), VersionCut.new(version_string))
-        interval = interval.intersect(new_interval)
-      when ">"
-        new_interval = VersionInterval.new(IntervalType::LEFT_OPEN | IntervalType::RIGHT_OPEN, VersionCut.new(version_string), AboveAll.new())
-        interval = interval.intersect(new_interval)
-      when "=", "=="
-        new_interval = VersionInterval.new(IntervalType::LEFT_CLOSED | IntervalType::RIGHT_CLOSED, VersionCut.new(version_string), VersionCut.new(version_string))
-        interval = interval.intersect(new_interval)
-      end
-    end
-    interval
-  end
-end

data/lib/semver_dialects/semantic_version/version_range.rb

@@ -1,191 +0,0 @@
-# frozen_string_literal: true
-
-require_relative 'version_parser'
-require 'set'
-
-# VersionRange is a utility class that helps managing consecutive version ranges automatically
-# given that they are added in-order
-# Note that join_if_possible should be only activated in case the ranges are added in consecutive order!!
-class VersionRange
-  attr_reader :version_intervals, :join_if_possible
-
-  def initialize(join_if_possible = true)
-    @version_intervals = []
-    @version_interval_set = Set.new
-    @join_if_possible = join_if_possible
-  end
-
-  def add_all(version_range)
-    version_range.version_intervals.each { |interval| add(interval) }
-  end
-
-  def add(version_interval)
-    return if @version_interval_set.include?(version_interval)
-
-    if @join_if_possible
-      if @version_intervals.empty?
-        @version_intervals << version_interval
-        @version_interval_set.add(version_interval)
-      else
-        last = @version_intervals.last
-        # nothing to do
-        return if last.end_cut == version_interval.start_cut && last.end_cut.value == version_interval.start_cut.value
-
-        if last.joinable?(version_interval)
-          @version_intervals[@version_intervals.size - 1] = last.join(version_interval)
-        else
-          @version_intervals << version_interval
-          @version_interval_set.add(version_interval)
-        end
-      end
-    else
-      @version_intervals << version_interval
-      @version_interval_set.add(version_interval)
-    end
-  end
-
-  def <<(item)
-    add(item)
-  end
-
-  def size
-    @version_intervals.size
-  end
-
-  def to_s
-    @version_intervals.map(&:to_s).join(',')
-  end
-
-  def to_description_s
-    @version_intervals.map(&:to_description_s).join(', ').capitalize
-  end
-
-  def to_npm_s
-    @version_intervals.map(&:to_npm_s).join('||')
-  end
-
-  def to_conan_s
-    to_npm_s
-  end
-
-  def to_nuget_s
-    to_maven_s
-  end
-
-  def to_maven_s
-    @version_intervals.map(&:to_maven_s).join(',')
-  end
-
-  def to_gem_s
-    @version_intervals.map(&:to_gem_s).join('||')
-  end
-
-  def to_pypi_s
-    @version_intervals.map(&:to_pypi_s).join('||')
-  end
-
-  def to_go_s
-    @version_intervals.map(&:to_go_s).join('||')
-  end
-
-  def to_packagist_s
-    @version_intervals.map(&:to_packagist_s).join('||')
-  end
-
-  def to_version_s(package_type)
-    case package_type
-    when 'npm'
-      to_npm_s
-    when 'nuget'
-      to_nuget_s
-    when 'maven'
-      to_maven_s
-    when 'gem'
-      to_gem_s
-    when 'pypi'
-      to_pypi_s
-    when 'packagist'
-      to_packagist_s
-    when 'go'
-      to_go_s
-    when 'conan'
-      to_conan_s
-    else
-      ''
-    end
-  end
-
-  # inverts the given version interval -- note that this function amy return two version intervals
-  # e.g.,       (2,10], (12, 13], [15, +inf)
-  # 1) invert:  (-inf, 2], (10, +inf), (-inf, 12], (13, +inf), (15)
-  # 2) collapse (-inf, 2], (10, 12], (13, 15)
-  #
-  # the collapsed inverted ranges can potentially contain fixed versions
-  def invert
-    inverted = @version_intervals.map(&:invert).flatten
-    version_intervals = collapse_intervals(inverted)
-    version_intervals_to_range(version_intervals)
-  end
-
-  def collapse
-    version_intervals = collapse_intervals(@version_intervals)
-    version_intervals_to_range(version_intervals)
-  end
-
-  def includes?(version_interval)
-    @version_interval_set.include?(version_interval)
-  end
-
-  def overlaps_with?(version_interval)
-    @version_interval_set.each do |interval|
-      return true unless interval.intersect(version_interval).instance_of? EmptyInterval
-    end
-    false
-  end
-
-  def first
-    @version_intervals.first
-  end
-
-  def empty?
-    @version_intervals.empty?
-  end
-
-  def any?
-    @version_intervals.any?
-  end
-
-  def universal?
-    @version_intervals.each do |version_interval|
-      return true if version_interval.universal?
-    end
-    false
-  end
-
-  private
-
-  def version_intervals_to_range(version_intervals)
-    ret = VersionRange.new(false)
-    version_intervals.each do |version_interval|
-      ret << version_interval
-    end
-    ret
-  end
-
-  def collapse_intervals(version_intervals)
-    interval_cp = []
-    interval_cp += version_intervals
-    ret = [interval_cp.shift]
-
-    interval_cp.each do |item|
-      last = ret.last
-      if last.intersect(item).instance_of?(EmptyInterval)
-        ret << item
-      else
-        ret.pop
-        ret << last.collapse(item)
-      end
-    end
-    ret
-  end
-end

data/lib/semver_dialects/semantic_version/version_translator.rb

@@ -1,172 +0,0 @@
-# frozen_string_literal: true
-
-require_relative '../../utils.rb'
-
-# A prepropcessor -- convert different version strings to something that can be digested by the
-# version parser
-module VersionTranslator
-  def self.translate_npm(version_string)
-    version_string.split('||').map do |item|
-      add_missing_operator(single_space_after_operator(item.strip.gsub(/&&/, ' ')))
-    end
-  end
-
-  def self.translate_conan(version_string)
-    translate_npm(version_string)
-  end
-
-  def self.translate_go(version_string)
-    translate_gem(version_string)
-  end
-
-  def self.translate_gem(version_string)
-    version_string.split('||').map do |item|
-      add_missing_operator(single_space_after_operator(item.strip.gsub(/\s+/, ' ')))
-    end
-  end
-
-  def self.translate_packagist(version_string)
-    translate_pypi(version_string)
-  end
-
-  def self.translate_pypi(version_string)
-    version_string.split('||').map do |item|
-      add_missing_operator(single_space_after_operator(comma_to_space(item)))
-    end
-  end
-
-  def self.translate_nuget(version_string)
-    translate_maven(version_string)
-  end
-
-  def self.translate_maven(version_string)
-    lexing_maven_version_string(version_string).map { |item| translate_mvn_version_item(item) }
-  end
-
-  def self.add_missing_operator(version_string)
-    starts_with_operator?(version_string) ? version_string : "=#{version_string}"
-  end
-
-  def self.single_space_after_operator(version_string)
-    version_string.gsub(/([>=<]+) +/, '\1').gsub(/\s+/, ' ')
-  end
-
-  def self.starts_with_operator?(version_item)
-    version_item.match(/^[=><]/) ? true : false
-  end
-
-  def self.comma_to_space(version_string)
-    version_string.strip.gsub(/,/, ' ')
-  end
-
-  def self.lexing_maven_version_string(version_string)
-    open = false
-    substring = ''
-    ret = []
-    version_string.each_char do |c|
-      case c
-      when '(', '['
-        if open
-          puts "malformed maven version string #{version_string}"
-          exit(-1)
-        else
-          unless substring.empty?
-            ret << substring
-            substring = ''
-          end
-          open = true
-          substring += c
-        end
-      when ')', ']'
-        if !open
-          puts "malformed maven version string #{version_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 #{version_string}"
-      exit(-1)
-    end
-    ret << substring unless substring.empty?
-    ret
-  end
-
-  def self.parenthesized?(version_item)
-    version_item.match(/^[\(\[]/) && version_item.match(/[\]\)]$/) ? true : false
-  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