semver_dialects 2.0.2 → 3.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d8afd964094235e63624c76231df69d2723cab03721b06c35aac704b2c1284bc
-  data.tar.gz: a51b11c2b5121fb34dda52d94824ca9713e634691d0aa212cd1c29197b40a8e4
+  metadata.gz: 19c2562420fb945c665db99cfeb6ac46186f65b10b4a84ba073aa8e0b443666e
+  data.tar.gz: 73d80ecdaedfc906f4e24f1c9f5921f18e126c19d73722991de7f3d61d5b2f24
 SHA512:
-  metadata.gz: ce87db5b620f138cd1058c5fb134bc33f7ea136d5dc5f5ba45626e97071d0eba5727e35ecf07cb509d23e08fbbe0838970e0480ba86d17843f416b3b409a6ea7
-  data.tar.gz: 2194ee64c814f01bdfd51418e3cae3acc451277fab265f5212049dc304ea378bacc6fef76d6786ad9495d23f6a0e2f1fe0eeb809496eb39a0c70725929fad6f3
+  metadata.gz: 28e168351b5eda9bf282416c58b52d5fb60ea768f5cb4ecc59c75a16c212b1425878d7a68133538eefea885dd4d430e7fc2d47359b103b31e72970fc69b88643
+  data.tar.gz: b20653d1d36eb4e21de3ae2e5962e1435885dd4a40988279394f733876eb6b4de9d6e6c04badd0222c14cb1af5ce00b9ac0abd747db7eab1908a3d5db3fa1f0b

data/lib/semver_dialects/base_version.rb

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+# Class that describes a version that can be compared to another version in a generic way.
+#
+# A version is made of +tokens+ and an optional +addition+.
+# Tokens and additions must be comparable using the spaceship operator.
+# An addition behaves like a version and must respond to +tokens+.
+#
+# Tokens are used to represent the dot separated list of segments
+# like 1.2.3 (semantic version) or alpha.1 (pre-release tag).
+#
+# Version 1.2.3-alpha.1-2024.03.25 is made of 3 +Version+ objects
+# whose tokens are represented as 1.2.3, alpha.1, 2024.03.25.
+# Version alpha.1 is the addition of version 1.2.3,
+# and version 2024.03.25 is the addition of version alpha.1.
+#
+# This class can support of the comparison logic of many syntaxes
+# by implementing specific token classes.
+#
+module SemverDialects
+  class BaseVersion
+    include Comparable
+
+    attr_reader :tokens, :addition
+
+    def initialize(tokens, addition: nil)
+      @tokens = tokens
+      @addition = addition
+    end
+
+    def to_s
+      main = tokens.join('.')
+      main += "-#{addition}" if addition
+      main
+    end
+
+    def <=>(other)
+      cmp = compare_tokens(tokens, other.tokens)
+      return cmp unless cmp == 0
+
+      compare_additions(addition, other.addition)
+    end
+
+    # Returns true if the version tokens are equivalent to zero
+    # and the addition is also equivalent to zero.
+    def is_zero?
+      return false if compare_tokens(tokens, [0]) != 0
+
+      return true if addition.nil?
+
+      addition.is_zero?
+    end
+
+    private
+
+    def compare_tokens(a, b) # rubocop:disable Naming/MethodParameterName
+      max_idx = [a.size, b.size].max - 1
+      (0..max_idx).each do |idx|
+        cmp = compare_token_pair(a[idx], b[idx])
+        return cmp unless cmp == 0
+      end
+      0
+    end
+
+    def compare_token_pair(a, b) # rubocop:disable Naming/MethodParameterName
+      (a || 0) <=> (b || 0)
+    end
+
+    def compare_additions(a, b) # rubocop:disable Naming/MethodParameterName
+      return 0 if a.nil? && b.nil?
+
+      (a || empty_addition).<=>(b || empty_addition)
+    end
+
+    def empty_addition
+      self.class.new([])
+    end
+  end
+end

data/lib/semver_dialects/boundary.rb

@@ -0,0 +1,142 @@
+# frozen_string_literal: true
+
+# Boundary is a boundary used in an interval.
+# It can either be above all versions (infinity),
+# below all versions (negative infinity), or any version.
+module SemverDialects
+  class Boundary
+    attr_accessor :semver
+
+    def initialize(semver)
+      @semver = semver
+    end
+
+    def to_s
+      @semver.to_s
+    end
+
+    def <(other)
+      if other.instance_of?(BelowAll)
+        false
+      else
+        other.instance_of?(AboveAll) ? true : @semver < other.semver
+      end
+    end
+
+    def >(other)
+      if other.instance_of?(BelowAll)
+        true
+      else
+        other.instance_of?(AboveAll) ? false : @semver > other.semver
+      end
+    end
+
+    def <=(other)
+      self < other || self == other
+    end
+
+    def >=(other)
+      self > other || self == other
+    end
+
+    def ==(other)
+      # self cannot be BelowAll or AboveAll
+      if other.instance_of?(BelowAll) || other.instance_of?(AboveAll)
+        false
+      else
+        @semver == other.semver
+      end
+    end
+
+    def !=(other)
+      # self cannot be BelowAll or AboveAll
+      if other.instance_of?(BelowAll) || other.instance_of?(AboveAll)
+        false
+      else
+        @semver != other.semver
+      end
+    end
+
+    def is_initial_version?
+      @semver.is_zero?
+    end
+  end
+
+  # BelowAll represents a boundary below all possible versions.
+  # When used as the lower boundary of an interval, any version
+  # that is smaller than the upper boundary is in the interval.
+  class BelowAll < Boundary
+    def initialize; end
+
+    def to_s
+      '-inf'
+    end
+
+    def is_initial_version?
+      false
+    end
+
+    def <(other)
+      other.instance_of?(BelowAll) ? false : true
+    end
+
+    def >(_other)
+      false
+    end
+
+    def <=(other)
+      self < other || self == other
+    end
+
+    def >=(other)
+      self > other || self == other
+    end
+
+    def ==(other)
+      (other.instance_of? BelowAll) ? true : false
+    end
+
+    def !=(other)
+      !(self == other)
+    end
+  end
+
+  # AboveAll represents a boundary above all possible versions.
+  # When used as the upper boundary of an interval, any version
+  # that is greater than the lower boundary is in the interval.
+  class AboveAll < Boundary
+    def initialize; end
+
+    def to_s
+      '+inf'
+    end
+
+    def is_initial_version?
+      false
+    end
+
+    def <(_other)
+      false
+    end
+
+    def >(other)
+      other.instance_of?(AboveAll) ? false : true
+    end
+
+    def <=(other)
+      self < other || self == other
+    end
+
+    def >=(other)
+      self > other || self == other
+    end
+
+    def ==(other)
+      (other.instance_of? AboveAll) ? true : false
+    end
+
+    def !=(other)
+      !(self == other)
+    end
+  end
+end

data/lib/semver_dialects/commands/check_version.rb

@@ -1,10 +1,7 @@
 # frozen_string_literal: true
 
 require_relative '../command'
-require_relative '../../semver_dialects.rb'
-require_relative '../semantic_version/version_translator.rb'
-require_relative '../semantic_version/version_parser.rb'
-require_relative '../semantic_version/version_range.rb'
+require_relative '../../semver_dialects'
 
 module SemverDialects
   module Commands
@@ -22,7 +19,7 @@ module SemverDialects
         typ = @type.downcase
         raise SemverDialects::Error, 'wrong package type' unless @avail_types.include?(typ)
 
-        if VersionChecker.version_sat?(typ, @version, @constraint)
+        if SemverDialects.version_satisfies?(typ, @version, @constraint)
           output.puts "#{@version} matches #{@constraint} for #{@type}"
           0
         else

data/lib/semver_dialects/interval.rb

@@ -0,0 +1,256 @@
+# frozen_string_literal: true
+
+module SemverDialects
+  module IntervalType
+    UNKNOWN = 0
+    LEFT_OPEN = 1
+    LEFT_CLOSED = 2
+    RIGHT_OPEN = 4
+    RIGHT_CLOSED = 8
+  end
+
+  # Interval is an interval that starts with a lower boundary
+  # and ends with an upper boundary. The interval includes the boundaries
+  # or not depending on its type.
+  class Interval
+    # Returns an interval that only includes the given version.
+    def self.from_version(version)
+      boundary = Boundary.new(version)
+      Interval.new(IntervalType::LEFT_CLOSED | IntervalType::RIGHT_CLOSED, boundary, boundary)
+    end
+
+    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 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 = Interval.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 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 distinct?
+        s = "version #{@start_cut}"
+      elsif universal?
+        s = 'all versions '
+      else
+        s = 'all versions '
+        s += if start_cut.instance_of?(BelowAll)
+               ''
+             elsif bit_set?(IntervalType::LEFT_OPEN)
+               "after #{@start_cut} "
+             else
+               bit_set?(IntervalType::LEFT_CLOSED) ? "starting from #{@start_cut} " : ''
+             end
+        s += if end_cut.instance_of?(AboveAll)
+               ''
+             elsif bit_set?(IntervalType::RIGHT_OPEN)
+               "before #{@end_cut}"
+             else
+               bit_set?(IntervalType::RIGHT_CLOSED) ? "up to #{@end_cut}" : ''
+             end
+      end
+      s.strip
+    end
+
+    def to_nuget_s
+      to_maven_s
+    end
+
+    def to_maven_s
+      s = ''
+      # special case -- distinct version
+      if distinct?
+        s += "[#{@start_cut}]"
+      else
+        s += if start_cut.instance_of?(BelowAll)
+               '(,'
+             elsif bit_set?(IntervalType::LEFT_OPEN)
+               "[#{@start_cut},"
+             else
+               bit_set?(IntervalType::LEFT_CLOSED) ? "[#{@start_cut}," : ''
+             end
+        s += if end_cut.instance_of?(AboveAll)
+               ')'
+             elsif bit_set?(IntervalType::RIGHT_OPEN)
+               "#{@end_cut})"
+             else
+               bit_set?(IntervalType::RIGHT_CLOSED) ? "#{@end_cut}]" : ''
+             end
+      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?
+      instance_of?(EmptyInterval)
+    end
+
+    def singleton?
+      @start_cut == @end_cut && @start_cut.semver == @end_cut.semver
+    end
+
+    def ==(other)
+      @start_cut == other.start_cut && @end_cut == other.end_cut && @type == other.type
+    end
+
+    def bit_set?(interval_type)
+      @type & interval_type != 0
+    end
+
+    protected
+
+    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
+        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
+        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 get_canoncial_s(delimiter = ' ', eq = '=')
+      if distinct?
+        "#{eq}#{@start_cut}"
+      else
+        first = if start_cut.instance_of?(BelowAll)
+                  ''
+                elsif bit_set?(IntervalType::LEFT_OPEN)
+                  ">#{@start_cut}"
+                else
+                  bit_set?(IntervalType::LEFT_CLOSED) ? ">=#{@start_cut}" : ''
+                end
+        second = if end_cut.instance_of?(AboveAll)
+                   ''
+                 elsif bit_set?(IntervalType::RIGHT_OPEN)
+                   "<#{@end_cut}"
+                 else
+                   bit_set?(IntervalType::RIGHT_CLOSED) ? "<=#{@end_cut}" : ''
+                 end
+        !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 < Interval
+    def initialize; end
+
+    def to_s
+      'empty'
+    end
+  end
+end

data/lib/semver_dialects/interval_parser.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+# IntervalParser parses a simple constraint expressed in the npm syntax
+# (or equivalent) and returns a Interval that has an upper boundary
+# or a lower boundary.
+#
+# The constraint is a string that can either be:
+# - an operator (>, <, >=, <=, =) followed by a version
+# - a version; the interval starts and ends with that version
+# - "=*"; the interval has no boundaries and includes any version
+#
+# Technically IntervalParser returns a Interval such as
+# start_cut is BelowAll or end_cut is AboveAll.
+# The type of the Interval matches the operator
+# that's been detected.
+#
+module SemverDialects
+  module IntervalParser
+    # A constraint is made of an operator followed by a version string.
+    # Use the regular expression of the SemanticVersion because this is the most generic one.
+    CONSTRAINT_REGEXP = Regexp.new("(?<op>[><=]+) *(?<version>#{SemanticVersion::VERSION_PATTERN})").freeze
+
+    def self.parse(typ, versionstring)
+      if versionstring == '=*'
+        # special case = All Versions
+        return Interval.new(IntervalType::LEFT_OPEN | IntervalType::RIGHT_OPEN, BelowAll.new, AboveAll.new)
+      end
+
+      version_items = versionstring.split(' ')
+      interval = Interval.new(IntervalType::LEFT_OPEN | IntervalType::RIGHT_OPEN, BelowAll.new, AboveAll.new)
+      version_items.each do |version_item|
+        matches = version_item.match CONSTRAINT_REGEXP
+        raise InvalidConstraintError, versionstring if matches.nil?
+
+        version = SemverDialects.parse_version(typ, matches[:version])
+        boundary = Boundary.new(version)
+        case matches[:op]
+        when '>='
+          new_interval = Interval.new(IntervalType::LEFT_CLOSED | IntervalType::RIGHT_OPEN, boundary, AboveAll.new)
+          interval = interval.intersect(new_interval)
+        when '<='
+          new_interval = Interval.new(IntervalType::LEFT_OPEN | IntervalType::RIGHT_CLOSED, BelowAll.new, boundary)
+          interval = interval.intersect(new_interval)
+        when '<'
+          new_interval = Interval.new(IntervalType::LEFT_OPEN | IntervalType::RIGHT_OPEN, BelowAll.new, boundary)
+          interval = interval.intersect(new_interval)
+        when '>'
+          new_interval = Interval.new(IntervalType::LEFT_OPEN | IntervalType::RIGHT_OPEN, boundary, AboveAll.new)
+          interval = interval.intersect(new_interval)
+        when '=', '=='
+          new_interval = Interval.new(IntervalType::LEFT_CLOSED | IntervalType::RIGHT_CLOSED, boundary, boundary)
+          interval = interval.intersect(new_interval)
+        end
+      end
+      interval
+    rescue InvalidVersionError
+      raise InvalidConstraintError, versionstring
+    end
+  end
+end

data/lib/semver_dialects/interval_set.rb

@@ -0,0 +1,121 @@
+# frozen_string_literal: true
+
+# IntervalSet is a disjunction of version intervals.
+# It can express a range like "[1.0,2.0],[3.0,4.0]" (Maven syntax),
+# that is between 1.0 and 2.0 (included) OR between 3.0 and 4.0 (included).
+module SemverDialects
+  class IntervalSet
+    attr_reader :intervals
+
+    def initialize
+      @intervals = []
+      @interval_set = Set.new
+    end
+
+    def add(interval)
+      @intervals << interval
+      @interval_set.add(interval)
+    end
+
+    def <<(item)
+      add(item)
+    end
+
+    def size
+      @intervals.size
+    end
+
+    def to_s
+      @intervals.map(&:to_s).join(',')
+    end
+
+    def to_description_s
+      @intervals.map(&:to_description_s).join(', ').capitalize
+    end
+
+    def to_npm_s
+      @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
+      @intervals.map(&:to_maven_s).join(',')
+    end
+
+    def to_gem_s
+      @intervals.map(&:to_gem_s).join('||')
+    end
+
+    def to_pypi_s
+      @intervals.map(&:to_pypi_s).join('||')
+    end
+
+    def to_go_s
+      @intervals.map(&:to_go_s).join('||')
+    end
+
+    def to_packagist_s
+      @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
+
+    def includes?(other)
+      @interval_set.include?(other)
+    end
+
+    def overlaps_with?(other)
+      @interval_set.each do |interval|
+        return true unless interval.intersect(other).instance_of?(EmptyInterval)
+      end
+      false
+    end
+
+    def first
+      @intervals.first
+    end
+
+    def empty?
+      @intervals.empty?
+    end
+
+    def any?
+      @intervals.any?
+    end
+
+    def universal?
+      @intervals.each do |interval|
+        return true if interval.universal?
+      end
+      false
+    end
+  end
+end