semver_dialects 1.0.1

data/lib/semver_dialects/semantic_version/version_parser.rb

@@ -0,0 +1,37 @@
+require_relative "version_cut"
+require_relative "version_interval"
+
+module VersionParser
+  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 /(?<op>[><=]+) *(?<version>[a-zA-Z0-9\-_\.\*]+)/
+      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

@@ -0,0 +1,191 @@
+# 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

@@ -0,0 +1,172 @@
+# 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(&: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

data/lib/semver_dialects/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module SemverDialects
+  VERSION = '1.0.1'
+end

data/lib/utils.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+# monkey-patch String class
+class String
+  def unwrap
+    s = self
+    s = s[1..s.length - 1] if s.start_with?('(')
+    s = s[0..s.length - 2] if s.end_with?(')')
+    s
+  end
+
+  def present?
+    !empty?
+  end
+
+  def number?
+    true if Integer(self)
+  rescue StandardError
+    false
+  end
+
+  def initial
+    self[0, 1]
+  end
+
+  def unquote
+    delete_suffix('"').delete_prefix('"').delete_suffix('\'').delete_prefix('\'')
+  end
+
+  def csv_unquote
+    unquote.unquote.unquote
+  end
+
+  def remove_trailing_number
+    gsub(/([^\d]*)\d+$/, '\1')
+  end
+
+  def chars_only
+    gsub(/[^0-9A-Za-z]/, '')
+  end
+end